OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 1097 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1108 | 1108 |
1109 ScrollTree::ScrollTree() | 1109 ScrollTree::ScrollTree() |
1110 : currently_scrolling_node_id_(kInvalidNodeId), | 1110 : currently_scrolling_node_id_(kInvalidNodeId), |
1111 layer_id_to_scroll_offset_map_(ScrollTree::ScrollOffsetMap()) {} | 1111 layer_id_to_scroll_offset_map_(ScrollTree::ScrollOffsetMap()) {} |
1112 | 1112 |
1113 ScrollTree::~ScrollTree() {} | 1113 ScrollTree::~ScrollTree() {} |
1114 | 1114 |
1115 ScrollTree& ScrollTree::operator=(const ScrollTree& from) { | 1115 ScrollTree& ScrollTree::operator=(const ScrollTree& from) { |
1116 PropertyTree::operator=(from); | 1116 PropertyTree::operator=(from); |
1117 currently_scrolling_node_id_ = kInvalidNodeId; | 1117 currently_scrolling_node_id_ = kInvalidNodeId; |
1118 // layer_id_to_scroll_offset_map_ is intentionally omitted in operator=, | 1118 // Maps for ScrollOffsets/SyncedScrollOffsets are intentionally ommitted here |
Khushal
2017/01/11 23:04:53
Does this comment look accurate?
ajuma
2017/01/12 01:06:12
Yes, might be worth adding that the animation chan
Khushal
2017/01/12 01:20:49
Done.
| |
1119 // because we do not want to simply copy the map when property tree is | 1119 // since we can not directly copy them. Pushing of these updates from main |
1120 // propagating from pending to active. | 1120 // currently depends on Layer properties for scroll offset animation changes |
1121 // In the main to pending case, we do want to copy it, but this can be done by | 1121 // being pushed to impl first. |
1122 // calling UpdateScrollOffsetMap after the assignment; | |
1123 // In the other case, we want pending and active property trees to share the | |
1124 // same map. | |
1125 return *this; | 1122 return *this; |
1126 } | 1123 } |
1127 | 1124 |
1128 bool ScrollTree::operator==(const ScrollTree& other) const { | 1125 bool ScrollTree::operator==(const ScrollTree& other) const { |
1129 const ScrollTree::ScrollOffsetMap& other_scroll_offset_map = | 1126 if (layer_id_to_scroll_offset_map_ != other.layer_id_to_scroll_offset_map_) |
1130 other.scroll_offset_map(); | |
1131 if (layer_id_to_scroll_offset_map_.size() != other_scroll_offset_map.size()) | |
1132 return false; | 1127 return false; |
1133 | 1128 if (layer_id_to_synced_scroll_offset_map_ != |
1134 for (auto map_entry : layer_id_to_scroll_offset_map_) { | 1129 other.layer_id_to_synced_scroll_offset_map_) |
1135 int key = map_entry.first; | 1130 return false; |
1136 if (other_scroll_offset_map.find(key) == other_scroll_offset_map.end() || | |
1137 map_entry.second != layer_id_to_scroll_offset_map_.at(key)) | |
1138 return false; | |
1139 } | |
1140 | 1131 |
1141 bool is_currently_scrolling_node_equal = | 1132 bool is_currently_scrolling_node_equal = |
1142 currently_scrolling_node_id_ == other.currently_scrolling_node_id_; | 1133 currently_scrolling_node_id_ == other.currently_scrolling_node_id_; |
1143 | 1134 |
1144 return PropertyTree::operator==(other) && is_currently_scrolling_node_equal; | 1135 return PropertyTree::operator==(other) && is_currently_scrolling_node_equal; |
1145 } | 1136 } |
1146 | 1137 |
1138 #if DCHECK_IS_ON() | |
1139 void ScrollTree::CopyCompleteTreeState(const ScrollTree& other) { | |
1140 currently_scrolling_node_id_ = other.currently_scrolling_node_id_; | |
1141 layer_id_to_scrollbars_enabled_map_ = | |
1142 other.layer_id_to_scrollbars_enabled_map_; | |
1143 layer_id_to_scroll_offset_map_ = other.layer_id_to_scroll_offset_map_; | |
1144 layer_id_to_synced_scroll_offset_map_ = | |
1145 other.layer_id_to_synced_scroll_offset_map_; | |
1146 } | |
1147 #endif | |
1148 | |
1147 void ScrollTree::clear() { | 1149 void ScrollTree::clear() { |
1148 PropertyTree<ScrollNode>::clear(); | 1150 PropertyTree<ScrollNode>::clear(); |
1149 | 1151 |
1150 if (property_trees()->is_main_thread) { | 1152 if (property_trees()->is_main_thread) { |
1151 currently_scrolling_node_id_ = kInvalidNodeId; | 1153 currently_scrolling_node_id_ = kInvalidNodeId; |
1152 layer_id_to_scroll_offset_map_.clear(); | 1154 layer_id_to_scroll_offset_map_.clear(); |
1153 } | 1155 } |
1154 | 1156 |
1155 #if DCHECK_IS_ON() | 1157 #if DCHECK_IS_ON() |
1156 ScrollTree tree; | 1158 ScrollTree tree; |
1157 if (!property_trees()->is_main_thread) { | 1159 if (!property_trees()->is_main_thread) { |
1160 DCHECK(layer_id_to_scroll_offset_map_.empty()); | |
1158 tree.currently_scrolling_node_id_ = currently_scrolling_node_id_; | 1161 tree.currently_scrolling_node_id_ = currently_scrolling_node_id_; |
1159 tree.layer_id_to_scroll_offset_map_ = layer_id_to_scroll_offset_map_; | 1162 tree.layer_id_to_synced_scroll_offset_map_ = |
1163 layer_id_to_synced_scroll_offset_map_; | |
1160 } | 1164 } |
1161 DCHECK(tree == *this); | 1165 DCHECK(tree == *this); |
1162 #endif | 1166 #endif |
1163 } | 1167 } |
1164 | 1168 |
1165 gfx::ScrollOffset ScrollTree::MaxScrollOffset(int scroll_node_id) const { | 1169 gfx::ScrollOffset ScrollTree::MaxScrollOffset(int scroll_node_id) const { |
1166 const ScrollNode* scroll_node = Node(scroll_node_id); | 1170 const ScrollNode* scroll_node = Node(scroll_node_id); |
1167 gfx::SizeF scroll_bounds = | 1171 gfx::SizeF scroll_bounds = |
1168 gfx::SizeF(scroll_node->bounds.width(), scroll_node->bounds.height()); | 1172 gfx::SizeF(scroll_node->bounds.width(), scroll_node->bounds.height()); |
1169 | 1173 |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1262 gfx::Transform screen_space_transform( | 1266 gfx::Transform screen_space_transform( |
1263 1, 0, 0, 1, scroll_node->offset_to_transform_parent.x(), | 1267 1, 0, 0, 1, scroll_node->offset_to_transform_parent.x(), |
1264 scroll_node->offset_to_transform_parent.y()); | 1268 scroll_node->offset_to_transform_parent.y()); |
1265 screen_space_transform.ConcatTransform( | 1269 screen_space_transform.ConcatTransform( |
1266 transform_tree.ToScreen(transform_node->id)); | 1270 transform_tree.ToScreen(transform_node->id)); |
1267 if (scroll_node->should_flatten) | 1271 if (scroll_node->should_flatten) |
1268 screen_space_transform.FlattenTo2d(); | 1272 screen_space_transform.FlattenTo2d(); |
1269 return screen_space_transform; | 1273 return screen_space_transform; |
1270 } | 1274 } |
1271 | 1275 |
1272 SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) { | 1276 SyncedScrollOffset* ScrollTree::GetOrCreateSyncedScrollOffset(int layer_id) { |
1273 if (layer_id_to_scroll_offset_map_.find(layer_id) == | 1277 DCHECK(!property_trees()->is_main_thread); |
1274 layer_id_to_scroll_offset_map_.end()) { | 1278 if (layer_id_to_synced_scroll_offset_map_.find(layer_id) == |
1275 layer_id_to_scroll_offset_map_[layer_id] = new SyncedScrollOffset; | 1279 layer_id_to_synced_scroll_offset_map_.end()) { |
1280 layer_id_to_synced_scroll_offset_map_[layer_id] = new SyncedScrollOffset; | |
1276 } | 1281 } |
1277 return layer_id_to_scroll_offset_map_[layer_id].get(); | 1282 return layer_id_to_synced_scroll_offset_map_[layer_id].get(); |
1278 } | 1283 } |
1279 | 1284 |
1280 const SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) const { | 1285 const SyncedScrollOffset* ScrollTree::GetSyncedScrollOffset( |
1281 if (layer_id_to_scroll_offset_map_.find(layer_id) == | 1286 int layer_id) const { |
1282 layer_id_to_scroll_offset_map_.end()) { | 1287 DCHECK(!property_trees()->is_main_thread); |
1288 if (layer_id_to_synced_scroll_offset_map_.find(layer_id) == | |
1289 layer_id_to_synced_scroll_offset_map_.end()) { | |
1283 return nullptr; | 1290 return nullptr; |
1284 } | 1291 } |
1285 return layer_id_to_scroll_offset_map_.at(layer_id).get(); | 1292 return layer_id_to_synced_scroll_offset_map_.at(layer_id).get(); |
1286 } | 1293 } |
1287 | 1294 |
1288 const gfx::ScrollOffset ScrollTree::current_scroll_offset(int layer_id) const { | 1295 const gfx::ScrollOffset ScrollTree::current_scroll_offset(int layer_id) const { |
1289 return synced_scroll_offset(layer_id) | 1296 if (property_trees()->is_main_thread) { |
1290 ? synced_scroll_offset(layer_id)->Current( | 1297 ScrollOffsetMap::const_iterator it = |
1298 layer_id_to_scroll_offset_map_.find(layer_id); | |
1299 return it != layer_id_to_scroll_offset_map_.end() ? it->second | |
1300 : gfx::ScrollOffset(); | |
1301 } | |
1302 return GetSyncedScrollOffset(layer_id) | |
1303 ? GetSyncedScrollOffset(layer_id)->Current( | |
1291 property_trees()->is_active) | 1304 property_trees()->is_active) |
1292 : gfx::ScrollOffset(); | 1305 : gfx::ScrollOffset(); |
1293 } | 1306 } |
1294 | 1307 |
1295 gfx::ScrollOffset ScrollTree::PullDeltaForMainThread( | 1308 gfx::ScrollOffset ScrollTree::PullDeltaForMainThread( |
1296 SyncedScrollOffset* scroll_offset) { | 1309 SyncedScrollOffset* scroll_offset) { |
1297 // TODO(flackr): We should pass the fractional scroll deltas when Blink fully | 1310 // TODO(flackr): We should pass the fractional scroll deltas when Blink fully |
1298 // supports fractional scrolls. | 1311 // supports fractional scrolls. |
1299 // TODO(flackr): We should ideally round the fractional scrolls in the same | 1312 // TODO(flackr): We should ideally round the fractional scrolls in the same |
1300 // direction as the scroll will be snapped but for common cases this is | 1313 // direction as the scroll will be snapped but for common cases this is |
1301 // equivalent to rounding to the nearest integer offset. | 1314 // equivalent to rounding to the nearest integer offset. |
1302 gfx::ScrollOffset current_offset = | 1315 gfx::ScrollOffset current_offset = |
1303 scroll_offset->Current(property_trees()->is_active); | 1316 scroll_offset->Current(property_trees()->is_active); |
1304 gfx::ScrollOffset rounded_offset = | 1317 gfx::ScrollOffset rounded_offset = |
1305 gfx::ScrollOffset(roundf(current_offset.x()), roundf(current_offset.y())); | 1318 gfx::ScrollOffset(roundf(current_offset.x()), roundf(current_offset.y())); |
1306 scroll_offset->SetCurrent(rounded_offset); | 1319 scroll_offset->SetCurrent(rounded_offset); |
1307 gfx::ScrollOffset delta = scroll_offset->PullDeltaForMainThread(); | 1320 gfx::ScrollOffset delta = scroll_offset->PullDeltaForMainThread(); |
1308 scroll_offset->SetCurrent(current_offset); | 1321 scroll_offset->SetCurrent(current_offset); |
1309 return delta; | 1322 return delta; |
1310 } | 1323 } |
1311 | 1324 |
1312 void ScrollTree::CollectScrollDeltas(ScrollAndScaleSet* scroll_info, | 1325 void ScrollTree::CollectScrollDeltas(ScrollAndScaleSet* scroll_info, |
1313 int inner_viewport_layer_id) { | 1326 int inner_viewport_layer_id) { |
1314 for (auto map_entry : layer_id_to_scroll_offset_map_) { | 1327 DCHECK(!property_trees()->is_main_thread); |
1328 for (auto map_entry : layer_id_to_synced_scroll_offset_map_) { | |
1315 gfx::ScrollOffset scroll_delta = | 1329 gfx::ScrollOffset scroll_delta = |
1316 PullDeltaForMainThread(map_entry.second.get()); | 1330 PullDeltaForMainThread(map_entry.second.get()); |
1317 | 1331 |
1318 gfx::Vector2d scroll_delta_vector(scroll_delta.x(), scroll_delta.y()); | 1332 gfx::Vector2d scroll_delta_vector(scroll_delta.x(), scroll_delta.y()); |
1319 int layer_id = map_entry.first; | 1333 int layer_id = map_entry.first; |
1320 | 1334 |
1321 if (!scroll_delta.IsZero()) { | 1335 if (!scroll_delta.IsZero()) { |
1322 if (layer_id == inner_viewport_layer_id) { | 1336 if (layer_id == inner_viewport_layer_id) { |
1323 // Inner (visual) viewport is stored separately. | 1337 // Inner (visual) viewport is stored separately. |
1324 scroll_info->inner_viewport_scroll.layer_id = layer_id; | 1338 scroll_info->inner_viewport_scroll.layer_id = layer_id; |
1325 scroll_info->inner_viewport_scroll.scroll_delta = scroll_delta_vector; | 1339 scroll_info->inner_viewport_scroll.scroll_delta = scroll_delta_vector; |
1326 } else { | 1340 } else { |
1327 LayerTreeHostCommon::ScrollUpdateInfo scroll; | 1341 LayerTreeHostCommon::ScrollUpdateInfo scroll; |
1328 scroll.layer_id = layer_id; | 1342 scroll.layer_id = layer_id; |
1329 scroll.scroll_delta = scroll_delta_vector; | 1343 scroll.scroll_delta = scroll_delta_vector; |
1330 scroll_info->scrolls.push_back(scroll); | 1344 scroll_info->scrolls.push_back(scroll); |
1331 } | 1345 } |
1332 } | 1346 } |
1333 } | 1347 } |
1334 } | 1348 } |
1335 | 1349 |
1336 void ScrollTree::CollectScrollDeltasForTesting() { | 1350 void ScrollTree::CollectScrollDeltasForTesting() { |
1337 for (auto map_entry : layer_id_to_scroll_offset_map_) { | 1351 for (auto map_entry : layer_id_to_synced_scroll_offset_map_) { |
1338 PullDeltaForMainThread(map_entry.second.get()); | 1352 PullDeltaForMainThread(map_entry.second.get()); |
1339 } | 1353 } |
1340 } | 1354 } |
1341 | 1355 |
1342 void ScrollTree::UpdateScrollOffsetMapEntry( | 1356 void ScrollTree::PushScrollUpdatesFromMainThread( |
1343 int key, | 1357 PropertyTrees* main_property_trees, |
1344 ScrollTree::ScrollOffsetMap* new_scroll_offset_map, | 1358 LayerTreeImpl* sync_tree) { |
1345 LayerTreeImpl* layer_tree_impl) { | 1359 DCHECK(!property_trees()->is_main_thread); |
1346 bool changed = false; | 1360 const ScrollOffsetMap& main_scroll_offset_map = |
1347 // If we are pushing scroll offset from main to pending tree, we create a new | 1361 main_property_trees->scroll_tree.layer_id_to_scroll_offset_map_; |
1348 // instance of synced scroll offset; if we are pushing from pending to active, | |
1349 // we reuse the pending tree's value in the map. | |
1350 if (!property_trees()->is_active) { | |
1351 changed = synced_scroll_offset(key)->PushFromMainThread( | |
1352 new_scroll_offset_map->at(key)->PendingBase()); | |
1353 | 1362 |
1354 if (new_scroll_offset_map->at(key)->clobber_active_value()) { | 1363 // We first want to clear SyncedProperty instances for layers which were |
1355 synced_scroll_offset(key)->set_clobber_active_value(); | 1364 // destroyed or became non-scrollable on the main thread. |
1356 } | 1365 for (auto map_entry = layer_id_to_synced_scroll_offset_map_.begin(); |
1357 if (changed) { | 1366 map_entry != layer_id_to_synced_scroll_offset_map_.end();) { |
1358 layer_tree_impl->DidUpdateScrollOffset(key); | 1367 int layer_id = map_entry->first; |
1359 } | 1368 if (main_scroll_offset_map.find(layer_id) == main_scroll_offset_map.end()) |
1360 } else { | 1369 map_entry = layer_id_to_synced_scroll_offset_map_.erase(map_entry); |
1361 layer_id_to_scroll_offset_map_[key] = new_scroll_offset_map->at(key); | 1370 else |
1362 changed |= synced_scroll_offset(key)->PushPendingToActive(); | 1371 map_entry++; |
1363 if (changed) { | 1372 } |
1364 layer_tree_impl->DidUpdateScrollOffset(key); | 1373 |
1365 } | 1374 for (auto map_entry : main_scroll_offset_map) { |
1375 int layer_id = map_entry.first; | |
1376 SyncedScrollOffset* synced_scroll_offset = | |
1377 GetOrCreateSyncedScrollOffset(layer_id); | |
1378 | |
1379 bool changed = synced_scroll_offset->PushFromMainThread(map_entry.second); | |
1380 // If we are committing directly to the active tree, push pending to active | |
1381 // here. | |
1382 if (property_trees()->is_active) | |
1383 changed |= synced_scroll_offset->PushPendingToActive(); | |
1384 | |
1385 if (changed) | |
1386 sync_tree->DidUpdateScrollOffset(layer_id); | |
1366 } | 1387 } |
1367 } | 1388 } |
1368 | 1389 |
1369 void ScrollTree::UpdateScrollOffsetMap( | 1390 void ScrollTree::PushScrollUpdatesFromPendingTree( |
1370 ScrollTree::ScrollOffsetMap* new_scroll_offset_map, | 1391 PropertyTrees* pending_property_trees, |
1371 LayerTreeImpl* layer_tree_impl) { | 1392 LayerTreeImpl* active_tree) { |
1372 if (layer_tree_impl && !layer_tree_impl->LayerListIsEmpty()) { | 1393 DCHECK(property_trees()->is_active); |
1373 DCHECK(!property_trees()->is_main_thread); | 1394 DCHECK(!pending_property_trees->is_main_thread); |
1374 for (auto map_entry = layer_id_to_scroll_offset_map_.begin(); | 1395 DCHECK(!pending_property_trees->is_active); |
1375 map_entry != layer_id_to_scroll_offset_map_.end();) { | |
1376 int key = map_entry->first; | |
1377 if (new_scroll_offset_map->find(key) != new_scroll_offset_map->end()) { | |
1378 UpdateScrollOffsetMapEntry(key, new_scroll_offset_map, layer_tree_impl); | |
1379 ++map_entry; | |
1380 } else { | |
1381 map_entry = layer_id_to_scroll_offset_map_.erase(map_entry); | |
1382 } | |
1383 } | |
1384 | 1396 |
1385 for (auto& map_entry : *new_scroll_offset_map) { | 1397 // When pushing to the active tree, we can simply copy over the map from the |
1386 int key = map_entry.first; | 1398 // pending tree. The pending and active tree hold a reference to the same |
1387 if (layer_id_to_scroll_offset_map_.find(key) == | 1399 // SyncedProperty instances. |
1388 layer_id_to_scroll_offset_map_.end()) | 1400 layer_id_to_synced_scroll_offset_map_.clear(); |
1389 UpdateScrollOffsetMapEntry(key, new_scroll_offset_map, layer_tree_impl); | 1401 for (auto map_entry : pending_property_trees->scroll_tree |
1390 } | 1402 .layer_id_to_synced_scroll_offset_map_) { |
1403 layer_id_to_synced_scroll_offset_map_[map_entry.first] = map_entry.second; | |
1404 if (map_entry.second->PushPendingToActive()) | |
1405 active_tree->DidUpdateScrollOffset(map_entry.first); | |
1391 } | 1406 } |
1392 } | 1407 } |
1393 | 1408 |
1394 ScrollTree::ScrollOffsetMap& ScrollTree::scroll_offset_map() { | |
1395 return layer_id_to_scroll_offset_map_; | |
1396 } | |
1397 | |
1398 const ScrollTree::ScrollOffsetMap& ScrollTree::scroll_offset_map() const { | |
1399 return layer_id_to_scroll_offset_map_; | |
1400 } | |
1401 | |
1402 void ScrollTree::ApplySentScrollDeltasFromAbortedCommit() { | 1409 void ScrollTree::ApplySentScrollDeltasFromAbortedCommit() { |
1403 DCHECK(property_trees()->is_active); | 1410 DCHECK(property_trees()->is_active); |
1404 for (auto& map_entry : layer_id_to_scroll_offset_map_) | 1411 for (auto& map_entry : layer_id_to_synced_scroll_offset_map_) |
1405 map_entry.second->AbortCommit(); | 1412 map_entry.second->AbortCommit(); |
1406 } | 1413 } |
1407 | 1414 |
1408 bool ScrollTree::SetBaseScrollOffset(int layer_id, | 1415 bool ScrollTree::SetBaseScrollOffset(int layer_id, |
1409 const gfx::ScrollOffset& scroll_offset) { | 1416 const gfx::ScrollOffset& scroll_offset) { |
1410 return synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset); | 1417 if (property_trees()->is_main_thread) { |
1418 layer_id_to_scroll_offset_map_[layer_id] = scroll_offset; | |
1419 return true; | |
1420 } | |
1421 | |
1422 // Scroll offset updates on the impl thread should only be for layers which | |
1423 // were created on the main thread. But this method is called when we build | |
1424 // PropertyTrees on the impl thread from LayerTreeImpl. | |
1425 return GetOrCreateSyncedScrollOffset(layer_id)->PushFromMainThread( | |
1426 scroll_offset); | |
1411 } | 1427 } |
1412 | 1428 |
1413 bool ScrollTree::SetScrollOffset(int layer_id, | 1429 bool ScrollTree::SetScrollOffset(int layer_id, |
1414 const gfx::ScrollOffset& scroll_offset) { | 1430 const gfx::ScrollOffset& scroll_offset) { |
1415 if (property_trees()->is_main_thread) | 1431 if (property_trees()->is_main_thread) { |
1416 return synced_scroll_offset(layer_id)->PushFromMainThread(scroll_offset); | 1432 if (layer_id_to_scroll_offset_map_[layer_id] == scroll_offset) |
1417 else if (property_trees()->is_active) | 1433 return false; |
1418 return synced_scroll_offset(layer_id)->SetCurrent(scroll_offset); | 1434 layer_id_to_scroll_offset_map_[layer_id] = scroll_offset; |
1435 return true; | |
1436 } | |
1437 | |
1438 if (property_trees()->is_active) { | |
1439 return GetOrCreateSyncedScrollOffset(layer_id)->SetCurrent(scroll_offset); | |
1440 } | |
1441 | |
1419 return false; | 1442 return false; |
1420 } | 1443 } |
1421 | 1444 |
1422 bool ScrollTree::UpdateScrollOffsetBaseForTesting( | 1445 bool ScrollTree::UpdateScrollOffsetBaseForTesting( |
1423 int layer_id, | 1446 int layer_id, |
1424 const gfx::ScrollOffset& offset) { | 1447 const gfx::ScrollOffset& offset) { |
1425 DCHECK(!property_trees()->is_main_thread); | 1448 DCHECK(!property_trees()->is_main_thread); |
1426 bool changed = synced_scroll_offset(layer_id)->PushFromMainThread(offset); | 1449 SyncedScrollOffset* synced_scroll_offset = |
1450 GetOrCreateSyncedScrollOffset(layer_id); | |
1451 bool changed = synced_scroll_offset->PushFromMainThread(offset); | |
1427 if (property_trees()->is_active) | 1452 if (property_trees()->is_active) |
1428 changed |= synced_scroll_offset(layer_id)->PushPendingToActive(); | 1453 changed |= synced_scroll_offset->PushPendingToActive(); |
1429 return changed; | 1454 return changed; |
1430 } | 1455 } |
1431 | 1456 |
1432 bool ScrollTree::SetScrollOffsetDeltaForTesting(int layer_id, | 1457 bool ScrollTree::SetScrollOffsetDeltaForTesting(int layer_id, |
1433 const gfx::Vector2dF& delta) { | 1458 const gfx::Vector2dF& delta) { |
1434 return synced_scroll_offset(layer_id)->SetCurrent( | 1459 return GetOrCreateSyncedScrollOffset(layer_id)->SetCurrent( |
1435 synced_scroll_offset(layer_id)->ActiveBase() + gfx::ScrollOffset(delta)); | 1460 GetSyncedScrollOffset(layer_id)->ActiveBase() + gfx::ScrollOffset(delta)); |
1436 } | 1461 } |
1437 | 1462 |
1438 const gfx::ScrollOffset ScrollTree::GetScrollOffsetBaseForTesting( | 1463 const gfx::ScrollOffset ScrollTree::GetScrollOffsetBaseForTesting( |
1439 int layer_id) const { | 1464 int layer_id) const { |
1440 DCHECK(!property_trees()->is_main_thread); | 1465 DCHECK(!property_trees()->is_main_thread); |
1441 if (synced_scroll_offset(layer_id)) | 1466 if (GetSyncedScrollOffset(layer_id)) |
1442 return property_trees()->is_active | 1467 return property_trees()->is_active |
1443 ? synced_scroll_offset(layer_id)->ActiveBase() | 1468 ? GetSyncedScrollOffset(layer_id)->ActiveBase() |
1444 : synced_scroll_offset(layer_id)->PendingBase(); | 1469 : GetSyncedScrollOffset(layer_id)->PendingBase(); |
1445 else | 1470 else |
1446 return gfx::ScrollOffset(); | 1471 return gfx::ScrollOffset(); |
1447 } | 1472 } |
1448 | 1473 |
1449 const gfx::ScrollOffset ScrollTree::GetScrollOffsetDeltaForTesting( | 1474 const gfx::ScrollOffset ScrollTree::GetScrollOffsetDeltaForTesting( |
1450 int layer_id) const { | 1475 int layer_id) const { |
1451 DCHECK(!property_trees()->is_main_thread); | 1476 DCHECK(!property_trees()->is_main_thread); |
1452 if (synced_scroll_offset(layer_id)) | 1477 if (GetSyncedScrollOffset(layer_id)) |
1453 return property_trees()->is_active | 1478 return property_trees()->is_active |
1454 ? synced_scroll_offset(layer_id)->Delta() | 1479 ? GetSyncedScrollOffset(layer_id)->Delta() |
1455 : synced_scroll_offset(layer_id)->PendingDelta().get(); | 1480 : GetSyncedScrollOffset(layer_id)->PendingDelta().get(); |
1456 else | 1481 else |
1457 return gfx::ScrollOffset(); | 1482 return gfx::ScrollOffset(); |
1458 } | 1483 } |
1459 | 1484 |
1460 void ScrollTree::DistributeScroll(ScrollNode* scroll_node, | 1485 void ScrollTree::DistributeScroll(ScrollNode* scroll_node, |
1461 ScrollState* scroll_state) { | 1486 ScrollState* scroll_state) { |
1462 DCHECK(scroll_node && scroll_state); | 1487 DCHECK(scroll_node && scroll_state); |
1463 if (scroll_state->FullyConsumed()) | 1488 if (scroll_state->FullyConsumed()) |
1464 return; | 1489 return; |
1465 scroll_state->DistributeToScrollChainDescendant(); | 1490 scroll_state->DistributeToScrollChainDescendant(); |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1594 changed = false; | 1619 changed = false; |
1595 non_root_surfaces_enabled = true; | 1620 non_root_surfaces_enabled = true; |
1596 sequence_number++; | 1621 sequence_number++; |
1597 | 1622 |
1598 #if DCHECK_IS_ON() | 1623 #if DCHECK_IS_ON() |
1599 PropertyTrees tree; | 1624 PropertyTrees tree; |
1600 tree.transform_tree = transform_tree; | 1625 tree.transform_tree = transform_tree; |
1601 tree.effect_tree = effect_tree; | 1626 tree.effect_tree = effect_tree; |
1602 tree.clip_tree = clip_tree; | 1627 tree.clip_tree = clip_tree; |
1603 tree.scroll_tree = scroll_tree; | 1628 tree.scroll_tree = scroll_tree; |
1604 // Scroll offset map and currently scrolling node id may not be copied | 1629 tree.scroll_tree.CopyCompleteTreeState(scroll_tree); |
1605 // during operator=. | |
1606 ScrollTree::ScrollOffsetMap& map = tree.scroll_tree.scroll_offset_map(); | |
1607 map = scroll_tree.scroll_offset_map(); | |
1608 tree.scroll_tree.set_currently_scrolling_node( | |
1609 scroll_tree.CurrentlyScrollingNodeId()); | |
1610 | 1630 |
1611 tree.sequence_number = sequence_number; | 1631 tree.sequence_number = sequence_number; |
1612 tree.is_main_thread = is_main_thread; | 1632 tree.is_main_thread = is_main_thread; |
1613 tree.is_active = is_active; | 1633 tree.is_active = is_active; |
1614 DCHECK(tree == *this); | 1634 DCHECK(tree == *this); |
1615 #endif | 1635 #endif |
1616 } | 1636 } |
1617 | 1637 |
1618 void PropertyTrees::SetInnerViewportContainerBoundsDelta( | 1638 void PropertyTrees::SetInnerViewportContainerBoundsDelta( |
1619 gfx::Vector2dF bounds_delta) { | 1639 gfx::Vector2dF bounds_delta) { |
(...skipping 432 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2052 | 2072 |
2053 const EffectNode* effect_node = effect_tree.Node(effect_id); | 2073 const EffectNode* effect_node = effect_tree.Node(effect_id); |
2054 | 2074 |
2055 bool success = GetFromTarget(transform_id, effect_id, transform); | 2075 bool success = GetFromTarget(transform_id, effect_id, transform); |
2056 transform->Scale(effect_node->surface_contents_scale.x(), | 2076 transform->Scale(effect_node->surface_contents_scale.x(), |
2057 effect_node->surface_contents_scale.y()); | 2077 effect_node->surface_contents_scale.y()); |
2058 return success; | 2078 return success; |
2059 } | 2079 } |
2060 | 2080 |
2061 } // namespace cc | 2081 } // namespace cc |
OLD | NEW |