chromium/components/commerce/core/parcel/parcels_manager.cc

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

#include "components/commerce/core/parcel/parcels_manager.h"

#include <set>

#include "base/functional/bind.h"
#include "base/time/clock.h"
#include "base/time/default_clock.h"
#include "components/commerce/core/parcel/parcels_server_proxy.h"
#include "components/commerce/core/parcel/parcels_storage.h"
#include "components/commerce/core/parcel/parcels_utils.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"

namespace commerce {

namespace {

constexpr base::TimeDelta kAboutToDeliverThreshold = …;
constexpr base::TimeDelta kRefreshIntervalForAboutToDeliver = …;
constexpr base::TimeDelta kDefaultRefreshInterval = …;

std::vector<ParcelIdentifier> ConvertParcelIdentifier(
    const std::vector<std::pair<ParcelIdentifier::Carrier, std::string>>&
        parcel_identifiers) { … }

bool IsParcelDone(const parcel_tracking_db::ParcelTrackingContent& tracking) { … }

std::vector<ParcelIdentifier> GetParcelIdentifiersToRefresh(
    base::Clock* clock,
    const std::vector<parcel_tracking_db::ParcelTrackingContent>&
        parcel_trackings) { … }

std::unique_ptr<std::vector<ParcelStatus>>
ConvertParcelTrackingContentsToParcelStatuses(
    const std::vector<parcel_tracking_db::ParcelTrackingContent>&
        parcel_trackings) { … }

std::unique_ptr<std::vector<ParcelTrackingStatus>> UpdateStoredParcelStatus(
    const std::vector<ParcelStatus>& stored_parcel_status,
    const std::vector<ParcelStatus>& parcel_status_to_update) { … }

}  // namespace

ParcelsManager::ParcelsManager(
    signin::IdentityManager* identity_manager,
    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
    SessionProtoStorage<parcel_tracking_db::ParcelTrackingContent>*
        parcel_tracking_proto_db)
    : … { … }

ParcelsManager::ParcelsManager(
    std::unique_ptr<ParcelsServerProxy> parcels_server_proxy,
    std::unique_ptr<ParcelsStorage> parcels_storage,
    base::Clock* clock)
    : … { … }

ParcelsManager::~ParcelsManager() = default;

void ParcelsManager::StartTrackingParcels(
    const std::vector<std::pair<ParcelIdentifier::Carrier, std::string>>&
        parcel_identifiers,
    const std::string& source_page_domain,
    GetParcelStatusCallback callback) { … }

void ParcelsManager::GetAllParcelStatuses(GetParcelStatusCallback callback) { … }

void ParcelsManager::StopTrackingParcel(const std::string& tracking_id,
                                        StopParcelTrackingCallback callback) { … }

void ParcelsManager::StopTrackingParcels(
    const std::vector<std::pair<ParcelIdentifier::Carrier, std::string>>&
        parcel_identifiers,
    StopParcelTrackingCallback callback) { … }

void ParcelsManager::StopTrackingAllParcels(
    StopParcelTrackingCallback callback) { … }

void ParcelsManager::ProcessPendingOperations() { … }

void ParcelsManager::OnParcelStorageInitialized(bool success) { … }

void ParcelsManager::StartTrackingParcelsInternal(
    const std::vector<std::pair<ParcelIdentifier::Carrier, std::string>>&
        parcel_identifiers,
    const std::string& source_page_domain,
    GetParcelStatusCallback callback) { … }

void ParcelsManager::GetAllParcelStatusesInternal(
    GetParcelStatusCallback callback) { … }

void ParcelsManager::StopTrackingParcelInternal(
    const std::string& tracking_id,
    StopParcelTrackingCallback callback) { … }

void ParcelsManager::StopTrackingParcelsInternal(
    const std::vector<std::pair<ParcelIdentifier::Carrier, std::string>>&
        parcel_identifiers,
    StopParcelTrackingCallback callback) { … }

void ParcelsManager::StopTrackingAllParcelsInternal(
    StopParcelTrackingCallback callback) { … }

void ParcelsManager::OnGetParcelStatusDone(
    std::unique_ptr<std::vector<ParcelStatus>> stored_parcel_status,
    bool has_stored_status,
    GetParcelStatusCallback callback,
    bool success,
    std::unique_ptr<std::vector<ParcelStatus>> new_parcel_status) { … }

void ParcelsManager::OnStopTrackingParcelDone(
    const std::string& tracking_id,
    StopParcelTrackingCallback callback,
    bool success) { … }

void ParcelsManager::OnStopTrackingParcelsDone(
    const std::vector<ParcelIdentifier>& parcel_identifiers,
    StopParcelTrackingCallback callback,
    bool success) { … }

void ParcelsManager::OnStopTrackingAllParcelsDone(
    StopParcelTrackingCallback callback,
    bool success) { … }

void ParcelsManager::OnCurrentOperationFinished() { … }

}  // namespace commerce