OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef CC_TILES_IMAGE_CONTROLLER_H_ | 5 #ifndef CC_TILES_IMAGE_CONTROLLER_H_ |
6 #define CC_TILES_IMAGE_CONTROLLER_H_ | 6 #define CC_TILES_IMAGE_CONTROLLER_H_ |
7 | 7 |
8 #include <set> | |
9 #include <vector> | 8 #include <vector> |
10 | 9 |
11 #include "base/macros.h" | 10 #include "base/macros.h" |
12 #include "base/memory/ref_counted.h" | 11 #include "base/memory/ref_counted.h" |
13 #include "base/memory/weak_ptr.h" | |
14 #include "base/threading/simple_thread.h" | |
15 #include "cc/base/cc_export.h" | 12 #include "cc/base/cc_export.h" |
16 #include "cc/base/unique_notifier.h" | |
17 #include "cc/playback/draw_image.h" | 13 #include "cc/playback/draw_image.h" |
18 #include "cc/raster/tile_task.h" | 14 #include "cc/raster/tile_task.h" |
19 #include "cc/tiles/image_decode_cache.h" | 15 #include "cc/tiles/image_decode_cache.h" |
20 | 16 |
21 namespace cc { | 17 namespace cc { |
22 | 18 |
23 class CC_EXPORT ImageController { | 19 class CC_EXPORT ImageController { |
24 public: | 20 public: |
25 using ImageDecodeRequestId = uint64_t; | 21 ImageController(); |
26 using ImageDecodedCallback = base::Callback<void(ImageDecodeRequestId)>; | 22 ~ImageController(); |
27 explicit ImageController( | |
28 base::SequencedTaskRunner* origin_task_runner, | |
29 scoped_refptr<base::SequencedTaskRunner> worker_task_runner); | |
30 virtual ~ImageController(); | |
31 | 23 |
32 void SetImageDecodeCache(ImageDecodeCache* cache); | 24 void SetImageDecodeCache(ImageDecodeCache* cache); |
33 void GetTasksForImagesAndRef( | 25 void GetTasksForImagesAndRef( |
34 std::vector<DrawImage>* images, | 26 std::vector<DrawImage>* images, |
35 std::vector<scoped_refptr<TileTask>>* tasks, | 27 std::vector<scoped_refptr<TileTask>>* tasks, |
36 const ImageDecodeCache::TracingInfo& tracing_info); | 28 const ImageDecodeCache::TracingInfo& tracing_info); |
37 void UnrefImages(const std::vector<DrawImage>& images); | 29 void UnrefImages(const std::vector<DrawImage>& images); |
38 void ReduceMemoryUsage(); | 30 void ReduceMemoryUsage(); |
39 std::vector<scoped_refptr<TileTask>> SetPredecodeImages( | 31 std::vector<scoped_refptr<TileTask>> SetPredecodeImages( |
40 std::vector<DrawImage> predecode_images, | 32 std::vector<DrawImage> predecode_images, |
41 const ImageDecodeCache::TracingInfo& tracing_info); | 33 const ImageDecodeCache::TracingInfo& tracing_info); |
42 | 34 |
43 // Virtual for testing. | |
44 virtual void UnlockImageDecode(ImageDecodeRequestId id); | |
45 | |
46 // This function requests that the given image be decoded and locked. Once the | |
47 // callback has been issued, it is passed an ID, which should be used to | |
48 // unlock this image. It is up to the caller to ensure that the image is later | |
49 // unlocked using UnlockImageDecode. | |
50 // Virtual for testing. | |
51 virtual ImageDecodeRequestId QueueImageDecode( | |
52 sk_sp<const SkImage> image, | |
53 const ImageDecodedCallback& callback); | |
54 | |
55 private: | 35 private: |
56 struct ImageDecodeRequest { | |
57 ImageDecodeRequest(); | |
58 ImageDecodeRequest(ImageDecodeRequestId id, | |
59 const DrawImage& draw_image, | |
60 const ImageDecodedCallback& callback, | |
61 scoped_refptr<TileTask> task, | |
62 bool need_unref); | |
63 ImageDecodeRequest(ImageDecodeRequest&& other); | |
64 ImageDecodeRequest(const ImageDecodeRequest& other); | |
65 ~ImageDecodeRequest(); | |
66 | |
67 ImageDecodeRequest& operator=(ImageDecodeRequest&& other); | |
68 ImageDecodeRequest& operator=(const ImageDecodeRequest& other); | |
69 | |
70 ImageDecodeRequestId id; | |
71 DrawImage draw_image; | |
72 ImageDecodedCallback callback; | |
73 scoped_refptr<TileTask> task; | |
74 bool need_unref; | |
75 }; | |
76 | |
77 void StopWorkerTasks(); | |
78 | |
79 // Called from the worker thread. | |
80 void ProcessNextImageDecodeOnWorkerThread(); | |
81 | |
82 void ImageDecodeCompleted(ImageDecodeRequestId id); | |
83 | |
84 ImageDecodeCache* cache_ = nullptr; | 36 ImageDecodeCache* cache_ = nullptr; |
85 std::vector<DrawImage> predecode_locked_images_; | 37 std::vector<DrawImage> predecode_locked_images_; |
86 | 38 |
87 static ImageDecodeRequestId s_next_image_decode_queue_id_; | |
88 std::unordered_map<ImageDecodeRequestId, DrawImage> requested_locked_images_; | |
89 | |
90 base::SequencedTaskRunner* origin_task_runner_ = nullptr; | |
91 scoped_refptr<base::SequencedTaskRunner> worker_task_runner_; | |
92 | |
93 // The variables defined below this lock (aside from weak_ptr_factory_) can | |
94 // only be accessed when the lock is acquired. | |
95 base::Lock lock_; | |
96 std::map<ImageDecodeRequestId, ImageDecodeRequest> image_decode_queue_; | |
97 std::map<ImageDecodeRequestId, ImageDecodeRequest> | |
98 requests_needing_completion_; | |
99 bool abort_tasks_ = false; | |
100 | |
101 base::WeakPtrFactory<ImageController> weak_ptr_factory_; | |
102 | |
103 DISALLOW_COPY_AND_ASSIGN(ImageController); | 39 DISALLOW_COPY_AND_ASSIGN(ImageController); |
104 }; | 40 }; |
105 | 41 |
106 } // namespace cc | 42 } // namespace cc |
107 | 43 |
108 #endif // CC_TILES_IMAGE_CONTROLLER_H_ | 44 #endif // CC_TILES_IMAGE_CONTROLLER_H_ |
OLD | NEW |