1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
// 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.
#ifndef CHROME_BROWSER_TASK_MANAGER_PROVIDERS_FALLBACK_TASK_PROVIDER_H_
#define CHROME_BROWSER_TASK_MANAGER_PROVIDERS_FALLBACK_TASK_PROVIDER_H_
#include <map>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/task_manager/providers/task_provider.h"
#include "chrome/browser/task_manager/providers/task_provider_observer.h"
namespace task_manager {
// This FallbackTaskProvider is created to manage a hierarchy of subproviders.
// Tasks from the primary subproviders are always shown in the Task Manager.
// Tasks from the secondary subprovider are only shown when no task from any of
// the primary providers exists for that process.
class FallbackTaskProvider : public TaskProvider {
public:
FallbackTaskProvider(
std::vector<std::unique_ptr<TaskProvider>> primary_subproviders,
std::unique_ptr<TaskProvider> secondary_subprovider);
FallbackTaskProvider(const FallbackTaskProvider&) = delete;
FallbackTaskProvider& operator=(const FallbackTaskProvider&) = delete;
~FallbackTaskProvider() override;
// task_manager::TaskProvider:
Task* GetTaskOfUrlRequest(int child_id, int route_id) override;
private:
friend class FallbackTaskProviderTest;
class SubproviderSource;
// task_manager::TaskProvider:
void StartUpdating() override;
void StopUpdating() override;
// This is used to show a task after |OnTaskAddedBySource| has decided that it
// is appropriate to show that task.
void ShowTask(Task* task);
// Called to add a task to the |pending_shown_tasks_| which delays showing the
// task for a duration controlled by kTimeDelayForPendingTask.
void ShowTaskLater(Task* task);
// This is called after the delay to show the task that has been delayed.
void ShowPendingTask(Task* task);
// This is used to hide a task after |OnTaskAddedBySource| has decided that it
// is appropriate to hide that task.
void HideTask(Task* task);
void OnTaskUnresponsive(Task* task);
void OnTaskAddedBySource(Task* task, SubproviderSource* source);
void OnTaskRemovedBySource(Task* task, SubproviderSource* source);
// Stores the wrapped subproviders.
std::vector<std::unique_ptr<SubproviderSource>> primary_sources_;
std::unique_ptr<SubproviderSource> secondary_source_;
// This is the set of tasks that this provider is currently passing up to
// whatever is observing it.
std::vector<raw_ptr<Task, VectorExperimental>> shown_tasks_;
// This maps a Task to a WeakPtrFactory so when a task is removed we can
// cancel showing a task that has been removed before it has been shown.
std::map<Task*, base::WeakPtrFactory<FallbackTaskProvider>>
pending_shown_tasks_;
// This flag specifies whether the use of a fallback task is an error. For
// releases it is, but the checking needs to be turned off during testing of
// this class itself.
bool allow_fallback_for_testing_ = false;
};
class FallbackTaskProvider::SubproviderSource : public TaskProviderObserver {
public:
SubproviderSource(FallbackTaskProvider* fallback_task_provider,
std::unique_ptr<TaskProvider> subprovider);
~SubproviderSource() override;
TaskProvider* subprovider() { return subprovider_.get(); }
std::vector<raw_ptr<Task, VectorExperimental>>* tasks() { return &tasks_; }
private:
friend class FallbackTaskProviderTest;
void TaskAdded(Task* task) override;
void TaskRemoved(Task* task) override;
void TaskUnresponsive(Task* task) override;
// The outer task provider on whose behalf we observe the |subprovider_|. This
// is a pointer back to the class that owns us.
raw_ptr<FallbackTaskProvider> fallback_task_provider_;
// The task provider that we are observing.
std::unique_ptr<TaskProvider> subprovider_;
// The vector of tasks that have been created by |subprovider_|.
std::vector<raw_ptr<Task, VectorExperimental>> tasks_;
};
} // namespace task_manager
#endif // CHROME_BROWSER_TASK_MANAGER_PROVIDERS_FALLBACK_TASK_PROVIDER_H_
|
