chromium/chrome/updater/ipc/update_service_proxy.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 "chrome/updater/ipc/update_service_proxy.h"

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/memory/scoped_refptr.h"
#include "base/sequence_checker.h"
#include "base/types/expected.h"
#include "base/version.h"
#include "chrome/updater/constants.h"
#include "chrome/updater/registration_data.h"
#include "chrome/updater/update_service.h"

namespace updater {
namespace {

bool CanRetry(int try_count) { … }

DoneFunc;

template <typename T>
void CallDone(scoped_refptr<UpdateServiceProxy> proxy,
              base::RepeatingCallback<void(
                  base::OnceCallback<void(base::expected<T, RpcError>)>)> call,
              base::OnceCallback<void(T)> callback,
              T default_response,
              int try_count,
              base::expected<T, RpcError> result) { … }

}  // namespace

UpdateServiceProxy::UpdateServiceProxy(
    scoped_refptr<UpdateServiceProxyImpl> proxy)
    : … { … }

void UpdateServiceProxy::GetVersion(
    base::OnceCallback<void(const base::Version&)> callback) { … }

void UpdateServiceProxy::FetchPolicies(base::OnceCallback<void(int)> callback) { … }

void UpdateServiceProxy::RegisterApp(const RegistrationRequest& request,
                                     base::OnceCallback<void(int)> callback) { … }

void UpdateServiceProxy::GetAppStates(
    base::OnceCallback<void(const std::vector<AppState>&)> callback) { … }

void UpdateServiceProxy::RunPeriodicTasks(base::OnceClosure callback) { … }

void UpdateServiceProxy::CheckForUpdate(
    const std::string& app_id,
    UpdateService::Priority priority,
    PolicySameVersionUpdate policy_same_version_update,
    base::RepeatingCallback<void(const UpdateState&)> state_update,
    base::OnceCallback<void(Result)> callback) { … }

void UpdateServiceProxy::Update(
    const std::string& app_id,
    const std::string& install_data_index,
    Priority priority,
    PolicySameVersionUpdate policy_same_version_update,
    base::RepeatingCallback<void(const UpdateState&)> state_update,
    base::OnceCallback<void(Result)> callback) { … }

void UpdateServiceProxy::UpdateAll(
    base::RepeatingCallback<void(const UpdateState&)> state_update,
    base::OnceCallback<void(Result)> callback) { … }

void UpdateServiceProxy::Install(
    const RegistrationRequest& registration,
    const std::string& client_install_data,
    const std::string& install_data_index,
    Priority priority,
    base::RepeatingCallback<void(const UpdateState&)> state_update,
    base::OnceCallback<void(Result)> callback) { … }

void UpdateServiceProxy::CancelInstalls(const std::string& app_id) { … }

void UpdateServiceProxy::RunInstaller(
    const std::string& app_id,
    const base::FilePath& installer_path,
    const std::string& install_args,
    const std::string& install_data,
    const std::string& install_settings,
    base::RepeatingCallback<void(const UpdateState&)> state_update,
    base::OnceCallback<void(Result)> callback) { … }

UpdateServiceProxy::~UpdateServiceProxy() { … }

}  // namespace updater