chromium/chrome/browser/task_manager/providers/fallback_task_provider.cc

// Copyright 2017 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/browser/task_manager/providers/fallback_task_provider.h"

#include <vector>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/process/process.h"
#include "base/task/single_thread_task_runner.h"
#include "chrome/browser/task_manager/providers/render_process_host_task_provider.h"
#include "chrome/browser/task_manager/providers/web_contents/web_contents_task_provider.h"
#include "content/public/browser/browser_thread.h"

BrowserThread;

namespace task_manager {

namespace {

constexpr base::TimeDelta kTimeDelayForPendingTask = …;

// Returns a task that is in the vector if the task in the vector shares a Pid
// with the other task.
Task* GetTaskByPidFromVector(
    base::ProcessId process_id,
    std::vector<raw_ptr<Task, VectorExperimental>>* which_vector) { … }

}  // namespace

FallbackTaskProvider::FallbackTaskProvider(
    std::vector<std::unique_ptr<TaskProvider>> primary_subproviders,
    std::unique_ptr<TaskProvider> secondary_subprovider)
    : … { … }

FallbackTaskProvider::~FallbackTaskProvider() { … }

Task* FallbackTaskProvider::GetTaskOfUrlRequest(int child_id, int route_id) { … }

void FallbackTaskProvider::StartUpdating() { … }

void FallbackTaskProvider::StopUpdating() { … }

void FallbackTaskProvider::ShowTaskLater(Task* task) { … }

void FallbackTaskProvider::ShowPendingTask(Task* task) { … }

void FallbackTaskProvider::ShowTask(Task* task) { … }

void FallbackTaskProvider::HideTask(Task* task) { … }

void FallbackTaskProvider::OnTaskAddedBySource(Task* task,
                                               SubproviderSource* source) { … }

void FallbackTaskProvider::OnTaskRemovedBySource(Task* task,
                                                 SubproviderSource* source) { … }

void FallbackTaskProvider::OnTaskUnresponsive(Task* task) { … }

FallbackTaskProvider::SubproviderSource::SubproviderSource(
    FallbackTaskProvider* fallback_task_provider,
    std::unique_ptr<TaskProvider> subprovider)
    : … { … }

FallbackTaskProvider::SubproviderSource::~SubproviderSource() { … }

void FallbackTaskProvider::SubproviderSource::TaskAdded(Task* task) { … }

void FallbackTaskProvider::SubproviderSource::TaskRemoved(Task* task) { … }

void FallbackTaskProvider::SubproviderSource::TaskUnresponsive(Task* task) { … }

}  // namespace task_manager