OLD | NEW |
---|---|
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 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 #include "cc/tiles/checker_image_tracker.h" | 5 #include "cc/tiles/checker_image_tracker.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/stl_util.h" | 8 #include "base/stl_util.h" |
9 #include "base/trace_event/trace_event.h" | 9 #include "base/trace_event/trace_event.h" |
10 | 10 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
42 "CheckerImageTracker::ScheduleImageDecodeQueue"); | 42 "CheckerImageTracker::ScheduleImageDecodeQueue"); |
43 // Only checker-imaged (async updated) images are decoded using the image | 43 // Only checker-imaged (async updated) images are decoded using the image |
44 // decode service. If |enable_checker_imaging_| is false, no image should | 44 // decode service. If |enable_checker_imaging_| is false, no image should |
45 // be checkered. | 45 // be checkered. |
46 DCHECK(image_decode_queue.empty() || enable_checker_imaging_); | 46 DCHECK(image_decode_queue.empty() || enable_checker_imaging_); |
47 | 47 |
48 image_decode_queue_ = std::move(image_decode_queue); | 48 image_decode_queue_ = std::move(image_decode_queue); |
49 ScheduleNextImageDecode(); | 49 ScheduleNextImageDecode(); |
50 } | 50 } |
51 | 51 |
52 const ImageIdFlatSet& CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() { | 52 const PaintImageIdFlatSet& |
53 CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() { | |
53 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 54 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
54 "CheckerImageTracker::TakeImagesToInvalidateOnSyncTree"); | 55 "CheckerImageTracker::TakeImagesToInvalidateOnSyncTree"); |
55 DCHECK_EQ(invalidated_images_on_current_sync_tree_.size(), 0u) | 56 DCHECK_EQ(invalidated_images_on_current_sync_tree_.size(), 0u) |
56 << "Sync tree can not be invalidated more than once"; | 57 << "Sync tree can not be invalidated more than once"; |
57 | 58 |
58 invalidated_images_on_current_sync_tree_.swap(images_pending_invalidation_); | 59 invalidated_images_on_current_sync_tree_.swap(images_pending_invalidation_); |
59 images_pending_invalidation_.clear(); | 60 images_pending_invalidation_.clear(); |
60 return invalidated_images_on_current_sync_tree_; | 61 return invalidated_images_on_current_sync_tree_; |
61 } | 62 } |
62 | 63 |
63 void CheckerImageTracker::DidActivateSyncTree() { | 64 void CheckerImageTracker::DidActivateSyncTree() { |
64 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 65 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
65 "CheckerImageTracker::DidActivateSyncTree"); | 66 "CheckerImageTracker::DidActivateSyncTree"); |
66 for (auto image_id : invalidated_images_on_current_sync_tree_) { | 67 for (auto image_id : invalidated_images_on_current_sync_tree_) { |
67 auto it = image_id_to_decode_request_id_.find(image_id); | 68 auto it = image_id_to_decode_request_id_.find(image_id); |
68 image_controller_->UnlockImageDecode(it->second); | 69 image_controller_->UnlockImageDecode(it->second); |
69 image_id_to_decode_request_id_.erase(it); | 70 image_id_to_decode_request_id_.erase(it); |
70 } | 71 } |
71 | 72 |
72 invalidated_images_on_current_sync_tree_.clear(); | 73 invalidated_images_on_current_sync_tree_.clear(); |
73 } | 74 } |
74 | 75 |
75 void CheckerImageTracker::DidFinishImageDecode( | 76 void CheckerImageTracker::DidFinishImageDecode( |
76 ImageId image_id, | 77 PaintImage::Id image_id, |
77 ImageController::ImageDecodeRequestId request_id, | 78 ImageController::ImageDecodeRequestId request_id, |
78 ImageController::ImageDecodeResult result) { | 79 ImageController::ImageDecodeResult result) { |
79 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 80 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
80 "CheckerImageTracker::DidFinishImageDecode"); | 81 "CheckerImageTracker::DidFinishImageDecode"); |
81 TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode", | 82 TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode", |
82 image_id); | 83 image_id); |
83 | 84 |
84 DCHECK_NE(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED, result); | 85 DCHECK_NE(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED, result); |
85 DCHECK_EQ(outstanding_image_decode_->uniqueID(), image_id); | 86 DCHECK_EQ(outstanding_image_decode_.value().stable_id(), image_id); |
86 | 87 |
87 outstanding_image_decode_ = nullptr; | 88 outstanding_image_decode_.reset(); |
88 image_async_decode_state_[image_id] = DecodePolicy::SYNC_DECODED_ONCE; | 89 image_async_decode_state_[image_id] = DecodePolicy::SYNC_DECODED_ONCE; |
89 images_pending_invalidation_.insert(image_id); | 90 images_pending_invalidation_.insert(image_id); |
90 | 91 |
91 ScheduleNextImageDecode(); | 92 ScheduleNextImageDecode(); |
92 client_->NeedsInvalidationForCheckerImagedTiles(); | 93 client_->NeedsInvalidationForCheckerImagedTiles(); |
93 } | 94 } |
94 | 95 |
95 bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image, | 96 bool CheckerImageTracker::ShouldCheckerImage(const PaintImage& image, |
96 WhichTree tree) { | 97 WhichTree tree) { |
97 TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id", | 98 TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id", |
98 image->uniqueID()); | 99 image.stable_id()); |
99 | 100 |
100 if (!enable_checker_imaging_) | 101 if (!enable_checker_imaging_) |
101 return false; | 102 return false; |
102 | 103 |
104 PaintImage::Id image_id = image.stable_id(); | |
105 | |
103 // If the image was invalidated on the current sync tree and the tile is | 106 // If the image was invalidated on the current sync tree and the tile is |
104 // for the active tree, continue checkering it on the active tree to ensure | 107 // for the active tree, continue checkering it on the active tree to ensure |
105 // the image update is atomic for the frame. | 108 // the image update is atomic for the frame. |
106 if (invalidated_images_on_current_sync_tree_.count(image->uniqueID()) != 0 && | 109 if (invalidated_images_on_current_sync_tree_.count(image_id) != 0 && |
107 tree == WhichTree::ACTIVE_TREE) { | 110 tree == WhichTree::ACTIVE_TREE) { |
108 return true; | 111 return true; |
109 } | 112 } |
110 | 113 |
111 // If the image is pending invalidation, continue checkering it. All tiles | 114 // If the image is pending invalidation, continue checkering it. All tiles |
112 // for these images will be invalidated on the next pending tree. | 115 // for these images will be invalidated on the next pending tree. |
113 if (images_pending_invalidation_.find(image->uniqueID()) != | 116 if (images_pending_invalidation_.find(image_id) != |
114 images_pending_invalidation_.end()) { | 117 images_pending_invalidation_.end()) { |
115 return true; | 118 return true; |
116 } | 119 } |
117 | 120 |
118 ImageId image_id = image->uniqueID(); | 121 auto insert_result = |
119 auto insert_result = image_async_decode_state_.insert( | 122 image_async_decode_state_.insert(std::pair<PaintImage::Id, DecodePolicy>( |
120 std::pair<ImageId, DecodePolicy>(image_id, DecodePolicy::ASYNC)); | 123 image_id, DecodePolicy::SYNC_PERMANENT)); |
vmpstr
2017/05/16 17:43:27
Why the change from ASYNC to SYNC_PERMANENT?
Khushal
2017/05/16 21:29:12
Because the value is not being updated in the can_
| |
121 auto it = insert_result.first; | 124 auto it = insert_result.first; |
122 if (insert_result.second) { | 125 if (insert_result.second) { |
123 size_t size = SafeSizeOfImage(image.get()); | 126 bool can_checker_image = |
124 it->second = (size >= kMinImageSizeToCheckerBytes && | 127 image.animation_type() == PaintImage::AnimationType::STATIC && |
125 size <= image_controller_->image_cache_max_limit_bytes()) | 128 image.completion_state() == PaintImage::CompletionState::DONE; |
126 ? DecodePolicy::ASYNC | 129 if (can_checker_image) { |
127 : DecodePolicy::SYNC_PERMANENT; | 130 size_t size = SafeSizeOfImage(image.sk_image().get()); |
131 it->second = (size >= kMinImageSizeToCheckerBytes && | |
132 size <= image_controller_->image_cache_max_limit_bytes()) | |
133 ? DecodePolicy::ASYNC | |
134 : DecodePolicy::SYNC_PERMANENT; | |
135 } | |
128 } | 136 } |
129 | 137 |
130 return it->second == DecodePolicy::ASYNC; | 138 return it->second == DecodePolicy::ASYNC; |
131 } | 139 } |
132 | 140 |
133 void CheckerImageTracker::ScheduleNextImageDecode() { | 141 void CheckerImageTracker::ScheduleNextImageDecode() { |
134 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 142 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
135 "CheckerImageTracker::ScheduleNextImageDecode"); | 143 "CheckerImageTracker::ScheduleNextImageDecode"); |
136 // We can have only one outsanding decode pending completion with the decode | 144 // We can have only one outsanding decode pending completion with the decode |
137 // service. We'll come back here when it is completed. | 145 // service. We'll come back here when it is completed. |
138 if (outstanding_image_decode_) | 146 if (outstanding_image_decode_.has_value()) |
139 return; | 147 return; |
140 | 148 |
141 while (!image_decode_queue_.empty()) { | 149 while (!image_decode_queue_.empty()) { |
142 auto candidate = std::move(image_decode_queue_.front()); | 150 auto candidate = std::move(image_decode_queue_.front()); |
143 image_decode_queue_.erase(image_decode_queue_.begin()); | 151 image_decode_queue_.erase(image_decode_queue_.begin()); |
144 | 152 |
145 // Once an image has been decoded, it can still be present in the decode | 153 // Once an image has been decoded, it can still be present in the decode |
146 // queue (duplicate entries), or while an image is still being skipped on | 154 // queue (duplicate entries), or while an image is still being skipped on |
147 // the active tree. Check if the image is still ASYNC to see if a decode is | 155 // the active tree. Check if the image is still ASYNC to see if a decode is |
148 // needed. | 156 // needed. |
149 ImageId image_id = candidate->uniqueID(); | 157 PaintImage::Id image_id = candidate.stable_id(); |
150 auto it = image_async_decode_state_.find(image_id); | 158 auto it = image_async_decode_state_.find(image_id); |
151 DCHECK(it != image_async_decode_state_.end()); | 159 DCHECK(it != image_async_decode_state_.end()); |
152 if (it->second != DecodePolicy::ASYNC) | 160 if (it->second != DecodePolicy::ASYNC) |
153 continue; | 161 continue; |
154 | 162 |
155 outstanding_image_decode_ = std::move(candidate); | 163 outstanding_image_decode_.emplace(candidate); |
156 break; | 164 break; |
157 } | 165 } |
158 | 166 |
159 // We either found an image to decode or we reached the end of the queue. If | 167 // We either found an image to decode or we reached the end of the queue. If |
160 // we couldn't find an image, we're done. | 168 // we couldn't find an image, we're done. |
161 if (!outstanding_image_decode_) { | 169 if (!outstanding_image_decode_.has_value()) { |
162 DCHECK(image_decode_queue_.empty()); | 170 DCHECK(image_decode_queue_.empty()); |
163 return; | 171 return; |
164 } | 172 } |
165 | 173 |
166 ImageId image_id = outstanding_image_decode_->uniqueID(); | 174 PaintImage::Id image_id = outstanding_image_decode_.value().stable_id(); |
167 DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0u); | 175 DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0u); |
168 TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode", | 176 TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode", |
169 image_id); | 177 image_id); |
170 image_id_to_decode_request_id_[image_id] = | 178 image_id_to_decode_request_id_[image_id] = |
171 image_controller_->QueueImageDecode( | 179 image_controller_->QueueImageDecode( |
172 outstanding_image_decode_, | 180 outstanding_image_decode_.value().sk_image(), |
173 base::Bind(&CheckerImageTracker::DidFinishImageDecode, | 181 base::Bind(&CheckerImageTracker::DidFinishImageDecode, |
174 weak_factory_.GetWeakPtr(), image_id)); | 182 weak_factory_.GetWeakPtr(), image_id)); |
175 } | 183 } |
176 | 184 |
177 } // namespace cc | 185 } // namespace cc |
OLD | NEW |