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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright 2014 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_THUMBNAIL_CC_THUMBNAIL_CACHE_H_
#define CHROME_BROWSER_THUMBNAIL_CC_THUMBNAIL_CACHE_H_
#include <stddef.h>
#include <list>
#include <map>
#include <set>
#include <vector>
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/memory/memory_pressure_listener.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/sequence_checker.h"
#include "base/task/sequenced_task_runner.h"
#include "base/time/time.h"
#include "chrome/browser/thumbnail/cc/etc1_thumbnail_helper.h"
#include "chrome/browser/thumbnail/cc/jpeg_thumbnail_helper.h"
#include "chrome/browser/thumbnail/cc/scoped_ptr_expiring_cache.h"
#include "chrome/browser/thumbnail/cc/thumbnail.h"
#include "chrome/browser/thumbnail/cc/thumbnail_capture_tracker.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "ui/android/resources/ui_resource_provider.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/size_f.h"
#include "url/gurl.h"
namespace base {
class Time;
}
namespace thumbnail {
typedef std::list<TabId> TabIdList;
class ThumbnailCacheObserver {
public:
virtual void OnThumbnailAddedToCache(TabId tab_id) = 0;
virtual void OnFinishedThumbnailRead(TabId tab_id) = 0;
};
class ThumbnailCache : ThumbnailDelegate {
public:
ThumbnailCache(size_t default_cache_size,
size_t compression_queue_max_size,
size_t write_queue_max_size,
bool save_jpeg_thumbnails);
ThumbnailCache(const ThumbnailCache&) = delete;
ThumbnailCache& operator=(const ThumbnailCache&) = delete;
~ThumbnailCache() override;
void SetUIResourceProvider(
base::WeakPtr<ui::UIResourceProvider> ui_resource_provider);
void AddThumbnailCacheObserver(ThumbnailCacheObserver* observer);
void RemoveThumbnailCacheObserver(ThumbnailCacheObserver* observer);
void Put(TabId tab_id,
std::unique_ptr<ThumbnailCaptureTracker, base::OnTaskRunnerDeleter>
tracker,
const SkBitmap& bitmap,
float thumbnail_scale);
void Remove(TabId tab_id);
Thumbnail* Get(TabId tab_id, bool force_disk_read);
void InvalidateThumbnailIfChanged(TabId tab_id, const GURL& url);
bool CheckAndUpdateThumbnailMetaData(TabId tab_id,
const GURL& url,
bool force_update);
bool IsInVisibleIds(TabId tab_id);
void UpdateVisibleIds(const std::vector<TabId>& priority,
TabId primary_tab_id);
void DecompressEtc1ThumbnailFromFile(
TabId tab_id,
base::OnceCallback<void(bool, const SkBitmap&)> post_decompress_callback);
// Called when resident textures were evicted, which requires paging
// in bitmaps.
void OnUIResourcesWereEvicted();
void SetCaptureMinRequestTimeForTesting(int timeMs);
// ThumbnailDelegate implementation
void InvalidateCachedThumbnail(Thumbnail* thumbnail) override;
static base::FilePath GetCacheDirectory();
private:
friend class ThumbnailCacheTest;
class ThumbnailMetaData {
public:
ThumbnailMetaData() = default;
ThumbnailMetaData(const base::Time& current_time, GURL url);
const GURL& url() const { return url_; }
base::Time capture_time() const { return capture_time_; }
private:
base::Time capture_time_;
GURL url_;
};
using ExpiringThumbnailCache = ScopedPtrExpiringCache<TabId, Thumbnail>;
using ThumbnailMetaDataMap = std::map<TabId, ThumbnailMetaData>;
void ScheduleRecordCacheMetrics(base::TimeDelta mean_delay);
void RecordCacheMetrics();
static size_t ComputeCacheSize(ExpiringThumbnailCache& cache);
void PruneCache();
void RemoveFromDisk(TabId tab_id);
void WriteEtc1ThumbnailIfNecessary(TabId tab_id,
sk_sp<SkPixelRef> compressed_data,
float scale,
const gfx::Size& content_size);
void WriteJpegThumbnailIfNecessary(
TabId tab_id,
std::unique_ptr<ThumbnailCaptureTracker, base::OnTaskRunnerDeleter>
tracker,
std::vector<uint8_t> compressed_data);
void SaveAsJpeg(TabId tab_id,
std::unique_ptr<ThumbnailCaptureTracker,
base::OnTaskRunnerDeleter> tracker,
const SkBitmap& bitmap);
void PostWriteJpegTask(std::unique_ptr<ThumbnailCaptureTracker,
base::OnTaskRunnerDeleter> tracker,
bool success);
void CompressThumbnailIfNecessary(
TabId tab_id,
std::unique_ptr<ThumbnailCaptureTracker, base::OnTaskRunnerDeleter>
tracker,
const base::Time& time_stamp,
const SkBitmap& bitmap,
float scale);
void ReadNextThumbnail();
void MakeSpaceForNewItemIfNecessary(TabId tab_id);
void RemoveFromReadQueue(TabId tab_id);
void PostWriteEtc1Task();
void PostEtc1CompressionTask(TabId tab_id,
const base::Time& time_stamp,
float scale,
sk_sp<SkPixelRef> compressed_data,
const gfx::Size& content_size);
void PostEtc1ReadTask(TabId tab_id,
sk_sp<SkPixelRef> compressed_data,
float scale,
const gfx::Size& content_size);
void NotifyObserversOfThumbnailAddedToCache(TabId tab_id);
void NotifyObserversOfThumbnailRead(TabId tab_id);
void RemoveOnMatchedTimeStamp(TabId tab_id, const base::Time& time_stamp);
void OnMemoryPressure(
base::MemoryPressureListener::MemoryPressureLevel level);
// Default priority as most of the time there is a placeholder available.
const scoped_refptr<base::SequencedTaskRunner>
etc1_file_sequenced_task_runner_;
// USER_VISIBLE priority as almost always used for Tab Switcher UI.
const scoped_refptr<base::SequencedTaskRunner>
jpeg_file_sequenced_task_runner_;
thumbnail::Etc1ThumbnailHelper etc1_helper_;
thumbnail::JpegThumbnailHelper jpeg_helper_;
const size_t compression_queue_max_size_;
const size_t write_queue_max_size_;
const bool save_jpeg_thumbnails_;
base::TimeDelta capture_min_request_time_ms_;
// TODO(crbug.com/40885026): Determine if these limits are still relevant.
// Remove or tune accordingly (i.e. split by jpeg and etc1).
size_t compression_tasks_count_;
size_t write_tasks_count_;
bool read_in_progress_;
ExpiringThumbnailCache cache_;
base::ObserverList<ThumbnailCacheObserver>::Unchecked observers_;
ThumbnailMetaDataMap thumbnail_meta_data_;
TabIdList read_queue_;
TabIdList visible_ids_;
TabId primary_tab_id_ = -1;
base::WeakPtr<ui::UIResourceProvider> ui_resource_provider_;
SEQUENCE_CHECKER(sequence_checker_);
std::unique_ptr<base::MemoryPressureListener> memory_pressure_;
base::WeakPtrFactory<ThumbnailCache> weak_factory_{this};
};
} // namespace thumbnail
#endif // CHROME_BROWSER_THUMBNAIL_CC_THUMBNAIL_CACHE_H_
|
