chromium/components/policy/core/common/async_policy_loader.cc

// Copyright 2013 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/policy/core/common/async_policy_loader.h"

#include <utility>

#include "base/functional/bind.h"
#include "base/location.h"
#include "base/task/sequenced_task_runner.h"
#include "build/build_config.h"
#include "components/policy/core/common/management/management_service.h"
#include "components/policy/core/common/management/platform_management_service.h"
#include "components/policy/core/common/policy_bundle.h"

Time;

namespace policy {

namespace {

// Amount of time to wait for the files on disk to settle before trying to load
// them. This alleviates the problem of reading partially written files and
// makes it possible to batch quasi-simultaneous changes.
constexpr base::TimeDelta kSettleInterval = …;

// The time interval for rechecking policy. This is the fallback in case the
// implementation never detects changes.
constexpr base::TimeDelta kReloadInterval = …;

}  // namespace

AsyncPolicyLoader::AsyncPolicyLoader(
    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
    bool periodic_updates)
    : … { … }

AsyncPolicyLoader::AsyncPolicyLoader(
    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
    ManagementService* management_service,
    bool periodic_updates)
    : … { … }

AsyncPolicyLoader::~AsyncPolicyLoader() { … }

Time AsyncPolicyLoader::LastModificationTime() { … }

void AsyncPolicyLoader::Reload(bool force) { … }

bool AsyncPolicyLoader::ShouldFilterSensitivePolicies() { … }

void AsyncPolicyLoader::SetPlatformManagementTrustworthinessAndReload(
    bool force,
    ManagementAuthorityTrustworthiness trustworthiness) { … }

bool AsyncPolicyLoader::NeedManagementBitBeforeLoad() { … }

PolicyBundle AsyncPolicyLoader::InitialLoad(
    const scoped_refptr<SchemaMap>& schema_map) { … }

void AsyncPolicyLoader::Init(
    scoped_refptr<base::SequencedTaskRunner> ui_thread_task_runner,
    const UpdateCallback& update_callback) { … }

void AsyncPolicyLoader::RefreshPolicies(scoped_refptr<SchemaMap> schema_map) { … }

void AsyncPolicyLoader::ScheduleNextReload(base::TimeDelta delay) { … }

bool AsyncPolicyLoader::IsSafeToReload(const Time& now,
                                       base::TimeDelta* delay) { … }

}  // namespace policy