parkable_string.cc | Explore in Territory

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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "third_party/blink/renderer/platform/bindings/parkable_string.h"

#include <array>
#include <string_view>

#include "base/check_op.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/process/memory.h"
#include "base/synchronization/lock.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "base/timer/elapsed_timer.h"
#include "base/trace_event/typed_macros.h"
#include "partition_alloc/oom.h"
#include "partition_alloc/partition_alloc.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/renderer/platform/bindings/buildflags.h"
#include "third_party/blink/renderer/platform/bindings/parkable_string_manager.h"
#include "third_party/blink/renderer/platform/crypto.h"
#include "third_party/blink/renderer/platform/disk_data_allocator.h"
#include "third_party/blink/renderer/platform/instrumentation/tracing/web_process_memory_dump.h"
#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
#include "third_party/blink/renderer/platform/scheduler/public/worker_pool.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
#include "third_party/blink/renderer/platform/wtf/allocator/partitions.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_base.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_std.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include "third_party/blink/renderer/platform/wtf/sanitizers.h"
#include "third_party/blink/renderer/platform/wtf/thread_specific.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
#include "third_party/snappy/src/snappy.h"
#include "third_party/zlib/google/compression_utils.h"

#if BUILDFLAG(HAS_ZSTD_COMPRESSION)
// "GN check" doesn't know that this file is only included when
// BUILDFLAG(HAS_ZSTD_COMPRESSION) is true. Disable it here.
#include "third_party/zstd/src/lib/zstd.h"  // nogncheck
#endif

namespace blink {

namespace {

ParkableStringImpl::Age MakeOlder(ParkableStringImpl::Age age) { … }

enum class ParkingAction { … };

void RecordLatencyHistogram(const char* histogram_name,
                            base::TimeDelta duration) { … }

void RecordThroughputHistogram(const char* histogram_name,
                               int throughput_mb_s) { … }

void RecordStatistics(size_t size,
                      base::TimeDelta duration,
                      ParkingAction action) { … }

void AsanPoisonString(const String& string) { … }

void AsanUnpoisonString(const String& string) { … }

// Char buffer allocated using PartitionAlloc, may be nullptr.
class NullableCharBuffer final { … };

}  // namespace

// Created and destroyed on the same thread, accessed on a background thread as
// well. |string|'s reference counting is *not* thread-safe, hence |string|'s
// reference count must *not* change on the background thread.
struct BackgroundTaskParams final { … };

// Valid transitions are:
//
// Compression:
// 1. kUnparked -> kParked: Parking completed normally
// 4. kParked -> kUnparked: String has been unparked.
//
// Disk:
// 1. kParked -> kOnDisk: Writing completed successfully
// 4. kOnDisk -> kUnParked: The string is requested, triggering a read and
//    decompression
//
// Since parking and disk writing are not synchronous operations the first time,
// when the asynchronous background task is posted,
// |background_task_in_progress_| is set to true. This prevents further string
// aging, and protects against concurrent background tasks.
//
// Each state can be combined with a string that is either old or
// young. Examples below:
// - kUnParked:
//   - (Very) Old: old strings are not necessarily parked
//   - Young: a string starts young and unparked.
// - kParked:
//   - (Very) Old: Parked, and not touched nor locked since then
//   - Young: Lock() makes a string young but doesn't unpark it.
// - kOnDisk:
//   - Very Old: On disk, and not touched nor locked since then
//   - Young: Lock() makes a string young but doesn't unpark it.
enum class ParkableStringImpl::State : uint8_t { … };

// Current "ownership" status of the underlying data.
//
// - kUnreferencedExternally: |string_| is not referenced externally, and the
//   class is free to change it.
// - kTooManyReferences: |string_| has multiple references pointing to it,
//   cannot change it.
// - kLocked: |this| is locked.
enum class ParkableStringImpl::Status : uint8_t { … };

ParkableStringImpl::ParkableMetadata::ParkableMetadata(
    String string,
    std::unique_ptr<SecureDigest> digest)
    : … { … }

// static
std::unique_ptr<ParkableStringImpl::SecureDigest>
ParkableStringImpl::HashString(StringImpl* string) { … }

// static
scoped_refptr<ParkableStringImpl> ParkableStringImpl::MakeNonParkable(
    scoped_refptr<StringImpl>&& impl) { … }

// static
scoped_refptr<ParkableStringImpl> ParkableStringImpl::MakeParkable(
    scoped_refptr<StringImpl>&& impl,
    std::unique_ptr<SecureDigest> digest) { … }

// static
ParkableStringImpl::CompressionAlgorithm
ParkableStringImpl::GetCompressionAlgorithm() { … }

ParkableStringImpl::ParkableStringImpl(scoped_refptr<StringImpl>&& impl,
                                       std::unique_ptr<SecureDigest> digest)
    : … { … }

ParkableStringImpl::~ParkableStringImpl() { … }

void ParkableStringImpl::Lock() { … }

void ParkableStringImpl::Unlock() { … }

const String& ParkableStringImpl::ToString() { … }

size_t ParkableStringImpl::CharactersSizeInBytes() const { … }

size_t ParkableStringImpl::MemoryFootprintForDump() const { … }

ParkableStringImpl::AgeOrParkResult ParkableStringImpl::MaybeAgeOrParkString() { … }

bool ParkableStringImpl::Park(ParkingMode mode) { … }

// Returns false if parking fails and will fail in the future (non-transient
// failure).
bool ParkableStringImpl::ParkInternal(ParkingMode mode) { … }

void ParkableStringImpl::DiscardUncompressedData() { … }

void ParkableStringImpl::DiscardCompressedData() { … }

bool ParkableStringImpl::is_parked_no_lock() const { … }

bool ParkableStringImpl::is_on_disk_no_lock() const { … }

bool ParkableStringImpl::is_compression_failed_no_lock() const { … }

bool ParkableStringImpl::is_parked() const { … }

bool ParkableStringImpl::is_on_disk() const { … }

ParkableStringImpl::Status ParkableStringImpl::CurrentStatus() const { … }

bool ParkableStringImpl::CanParkNow() const { … }

void ParkableStringImpl::Unpark() { … }

String ParkableStringImpl::UnparkInternal() { … }

void ParkableStringImpl::ReleaseAndRemoveIfNeeded() const { … }

void ParkableStringImpl::PostBackgroundCompressionTask() { … }

// static
void ParkableStringImpl::CompressInBackground(
    std::unique_ptr<BackgroundTaskParams> params) { … }

void ParkableStringImpl::OnParkingCompleteOnMainThread(
    std::unique_ptr<BackgroundTaskParams> params,
    std::unique_ptr<Vector<uint8_t>> compressed,
    base::TimeDelta parking_thread_time) { … }

void ParkableStringImpl::PostBackgroundWritingTask(
    std::unique_ptr<ReservedChunk> reserved_chunk) { … }

// static
void ParkableStringImpl::WriteToDiskInBackground(
    std::unique_ptr<BackgroundTaskParams> params,
    DiskDataAllocator* data_allocator) { … }

void ParkableStringImpl::OnWritingCompleteOnMainThread(
    std::unique_ptr<BackgroundTaskParams> params,
    std::unique_ptr<DiskDataMetadata> on_disk_metadata,
    base::TimeDelta writing_time) { … }

ParkableString::ParkableString(scoped_refptr<StringImpl>&& impl)
    : … { … }

ParkableString::ParkableString(
    scoped_refptr<StringImpl>&& impl,
    std::unique_ptr<ParkableStringImpl::SecureDigest> digest) { … }

ParkableString::~ParkableString() = default;

void ParkableString::Lock() const { … }

void ParkableString::Unlock() const { … }

void ParkableString::OnMemoryDump(WebProcessMemoryDump* pmd,
                                  const String& name) const { … }

bool ParkableString::Is8Bit() const { … }

const String& ParkableString::ToString() const { … }

size_t ParkableString::CharactersSizeInBytes() const { … }

}  // namespace blink
chromium/third_party/blink/renderer/platform/bindings/parkable_string.cc
