Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(130)

Side by Side Diff: Source/core/rendering/RenderLayerCompositor.cpp

Issue 22419002: Set up clip and scroll parents on the blink side. (Closed) Base URL: svn://svn.chromium.org/blink/trunk
Patch Set: . Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « Source/core/rendering/RenderLayerCompositor.h ('k') | public/platform/WebLayer.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (C) 2009, 2010 Apple Inc. All rights reserved. 2 * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
3 * 3 *
4 * Redistribution and use in source and binary forms, with or without 4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions 5 * modification, are permitted provided that the following conditions
6 * are met: 6 * are met:
7 * 1. Redistributions of source code must retain the above copyright 7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer. 8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright 9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the 10 * notice, this list of conditions and the following disclaimer in the
(...skipping 417 matching lines...) Expand 10 before | Expand all | Expand 10 after
428 m_secondaryBackingStoreBytes = 0; 428 m_secondaryBackingStoreBytes = 0;
429 429
430 Frame& frame = m_renderView->frameView()->frame(); 430 Frame& frame = m_renderView->frameView()->frame();
431 LOG(Compositing, "\nUpdate %d of %s.\n", m_rootLayerUpdateCount, isMainF rame() ? "main frame" : frame.tree()->uniqueName().string().utf8().data()); 431 LOG(Compositing, "\nUpdate %d of %s.\n", m_rootLayerUpdateCount, isMainF rame() ? "main frame" : frame.tree()->uniqueName().string().utf8().data());
432 } 432 }
433 #endif 433 #endif
434 434
435 if (needHierarchyUpdate) { 435 if (needHierarchyUpdate) {
436 // Update the hierarchy of the compositing layers. 436 // Update the hierarchy of the compositing layers.
437 Vector<GraphicsLayer*> childList; 437 Vector<GraphicsLayer*> childList;
438 HashSet<RenderLayer*> visited;
438 { 439 {
439 TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::rebuildCompo sitingLayerTree"); 440 TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::rebuildCompo sitingLayerTree");
440 rebuildCompositingLayerTree(updateRoot, childList, 0); 441 rebuildCompositingLayerTree(updateRoot, childList, visited, 0);
441 } 442 }
442 443
443 // Host the document layer in the RenderView's root layer. 444 // Host the document layer in the RenderView's root layer.
444 if (isFullUpdate) { 445 if (isFullUpdate) {
445 // Even when childList is empty, don't drop out of compositing mode if there are 446 // Even when childList is empty, don't drop out of compositing mode if there are
446 // composited layers that we didn't hit in our traversal (e.g. becau se of visibility:hidden). 447 // composited layers that we didn't hit in our traversal (e.g. becau se of visibility:hidden).
447 if (childList.isEmpty() && !hasAnyAdditionalCompositedLayers(updateR oot)) 448 if (childList.isEmpty() && !hasAnyAdditionalCompositedLayers(updateR oot))
448 destroyRootLayer(); 449 destroyRootLayer();
449 else 450 else
450 m_rootContentLayer->setChildren(childList); 451 m_rootContentLayer->setChildren(childList);
451 } 452 }
452 } else if (needGeometryUpdate) { 453 } else if (needGeometryUpdate) {
453 // We just need to do a geometry update. This is only used for position: fixed scrolling; 454 // We just need to do a geometry update. This is only used for position: fixed scrolling;
454 // most of the time, geometry is updated via RenderLayer::styleChanged() . 455 // most of the time, geometry is updated via RenderLayer::styleChanged() .
455 updateLayerTreeGeometry(updateRoot, 0); 456 HashSet<RenderLayer*> visited;
457 updateLayerTreeGeometry(updateRoot, visited, 0);
456 } 458 }
457 459
458 #if !LOG_DISABLED 460 #if !LOG_DISABLED
459 if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needG eometryUpdate)) { 461 if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needG eometryUpdate)) {
460 double endTime = currentTime(); 462 double endTime = currentTime();
461 LOG(Compositing, "Total layers primary secondary obligatory backin g (KB) secondary backing(KB) total backing (KB) update time (ms)\n"); 463 LOG(Compositing, "Total layers primary secondary obligatory backin g (KB) secondary backing(KB) total backing (KB) update time (ms)\n");
462 464
463 LOG(Compositing, "%8d %11d %9d %20.2f %22.2f %22.2f %18.2f\n", 465 LOG(Compositing, "%8d %11d %9d %20.2f %22.2f %22.2f %18.2f\n",
464 m_obligateCompositedLayerCount + m_secondaryCompositedLayerCount, m_ obligateCompositedLayerCount, 466 m_obligateCompositedLayerCount + m_secondaryCompositedLayerCount, m_ obligateCompositedLayerCount,
465 m_secondaryCompositedLayerCount, m_obligatoryBackingStoreBytes / 102 4, m_secondaryBackingStoreBytes / 1024, (m_obligatoryBackingStoreBytes + m_secon daryBackingStoreBytes) / 1024, 1000.0 * (endTime - startTime)); 467 m_secondaryCompositedLayerCount, m_obligatoryBackingStoreBytes / 102 4, m_secondaryBackingStoreBytes / 1024, (m_obligatoryBackingStoreBytes + m_secon daryBackingStoreBytes) / 1024, 1000.0 * (endTime - startTime));
(...skipping 568 matching lines...) Expand 10 before | Expand all | Expand 10 after
1034 } 1036 }
1035 1037
1036 bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const 1038 bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const
1037 { 1039 {
1038 if (!m_hasAcceleratedCompositing) 1040 if (!m_hasAcceleratedCompositing)
1039 return false; 1041 return false;
1040 1042
1041 return o->supportsAcceleratedRendering(); 1043 return o->supportsAcceleratedRendering();
1042 } 1044 }
1043 1045
1044 void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer* layer, Vect or<GraphicsLayer*>& childLayersOfEnclosingLayer, int depth) 1046 void RenderLayerCompositor::rebuildCompositingLayerTreeForLayerAndScrollParents( RenderLayer* curLayer, Vector<GraphicsLayer*>& childList, HashSet<RenderLayer*>& visited, HashMap<RenderLayer*, Vector<GraphicsLayer*> >& scrollParentChildLists , int depth)
1047 {
1048 ASSERT(curLayer->zIndex() >= 0 || !visited.contains(curLayer));
1049 if (visited.contains(curLayer)) {
1050 HashMap<RenderLayer*, Vector<GraphicsLayer*> >::iterator it = scrollPare ntChildLists.find(curLayer);
1051 ASSERT(it != scrollParentChildLists.end());
1052 childList.append(it->value);
1053 scrollParentChildLists.remove(it);
1054 return;
1055 }
1056
1057 if (requiresCompositingForOverflowScrollingParent(curLayer)) {
1058 RenderLayer* scrollParent = curLayer->ancestorScrollingLayer();
1059 if (!visited.contains(scrollParent)) {
1060 ASSERT(!scrollParentChildLists.contains(scrollParent));
1061 Vector<GraphicsLayer*> scrollParentChildList;
1062 rebuildCompositingLayerTreeForLayerAndScrollParents(scrollParent, sc rollParentChildList, visited, scrollParentChildLists, depth);
1063 scrollParentChildLists.add(scrollParent, scrollParentChildList);
1064 }
1065 }
1066
1067 rebuildCompositingLayerTree(curLayer, childList, visited, depth);
1068 }
1069
1070 void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer* layer, Vect or<GraphicsLayer*>& childLayersOfEnclosingLayer, HashSet<RenderLayer*>& visited, int depth)
1045 { 1071 {
1046 // Make the layer compositing if necessary, and set up clipping and content layers. 1072 // Make the layer compositing if necessary, and set up clipping and content layers.
1047 // Note that we can only do work here that is independent of whether the des cendant layers 1073 // Note that we can only do work here that is independent of whether the des cendant layers
1048 // have been processed. computeCompositingRequirements() will already have d one the repaint if necessary. 1074 // have been processed. computeCompositingRequirements() will already have d one the repaint if necessary.
1049 1075
1050 // Used for gathering UMA data about the effect on memory usage of promoting all layers 1076 // Used for gathering UMA data about the effect on memory usage of promoting all layers
1051 // that have a webkit-transition on opacity or transform and intersect the v iewport. 1077 // that have a webkit-transition on opacity or transform and intersect the v iewport.
1052 static double pixelsWithoutPromotingAllTransitions = 0.0; 1078 static double pixelsWithoutPromotingAllTransitions = 0.0;
1053 static double pixelsAddedByPromotingAllTransitions = 0.0; 1079 static double pixelsAddedByPromotingAllTransitions = 0.0;
1054 1080
1055 if (!depth) { 1081 if (!depth) {
1056 pixelsWithoutPromotingAllTransitions = 0.0; 1082 pixelsWithoutPromotingAllTransitions = 0.0;
1057 pixelsAddedByPromotingAllTransitions = 0.0; 1083 pixelsAddedByPromotingAllTransitions = 0.0;
1058 } 1084 }
1059 1085
1086 visited.add(layer);
1087
1060 RenderLayerBacking* layerBacking = layer->backing(); 1088 RenderLayerBacking* layerBacking = layer->backing();
1061 if (layerBacking) { 1089 if (layerBacking) {
1062 // The compositing state of all our children has been updated already, s o now 1090 // The compositing state of all our children has been updated already, s o now
1063 // we can compute and cache the composited bounds for this layer. 1091 // we can compute and cache the composited bounds for this layer.
1064 layerBacking->updateCompositedBounds(); 1092 layerBacking->updateCompositedBounds();
1065 1093
1066 if (RenderLayer* reflection = layer->reflectionLayer()) { 1094 if (RenderLayer* reflection = layer->reflectionLayer()) {
1067 if (reflection->backing()) 1095 if (reflection->backing())
1068 reflection->backing()->updateCompositedBounds(); 1096 reflection->backing()->updateCompositedBounds();
1069 } 1097 }
(...skipping 22 matching lines...) Expand all
1092 1120
1093 // If this layer has backing, then we are collecting its children, otherwise appending 1121 // If this layer has backing, then we are collecting its children, otherwise appending
1094 // to the compositing child list of an enclosing layer. 1122 // to the compositing child list of an enclosing layer.
1095 Vector<GraphicsLayer*> layerChildren; 1123 Vector<GraphicsLayer*> layerChildren;
1096 Vector<GraphicsLayer*>& childList = layerBacking ? layerChildren : childLaye rsOfEnclosingLayer; 1124 Vector<GraphicsLayer*>& childList = layerBacking ? layerChildren : childLaye rsOfEnclosingLayer;
1097 1125
1098 #if !ASSERT_DISABLED 1126 #if !ASSERT_DISABLED
1099 LayerListMutationDetector mutationChecker(layer); 1127 LayerListMutationDetector mutationChecker(layer);
1100 #endif 1128 #endif
1101 1129
1130 // Visit the normal flow descendants first. We do this for the sake of scrol l
1131 // parents. A scroll parent is not a stacking context, so it will either app ear
1132 // in the normal flow tree, or in the positive z-order list (if it had a pos itioned
1133 // ancestor). Visiting the scroll parent ahead of time if it appears in one
1134 // of these lists is a simple matter since we have the lists in hand at this
1135 // level of the recursion, but it's tricker for layers in the normal flow tr ee,
1136 // so it will be easier to just process this ahead of time.
1137 Vector<GraphicsLayer*> normalFlowChildList;
1138
1139 if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1140 size_t listSize = normalFlowList->size();
1141 for (size_t i = 0; i < listSize; ++i) {
1142 RenderLayer* curLayer = normalFlowList->at(i);
1143 rebuildCompositingLayerTree(curLayer, normalFlowChildList, visited, depth + 1);
1144 }
1145 }
1146
1147 HashMap<RenderLayer*, Vector<GraphicsLayer*> > scrollParentChildLists;
1102 if (layer->isStackingContainer()) { 1148 if (layer->isStackingContainer()) {
1103 if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) { 1149 if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1104 size_t listSize = negZOrderList->size(); 1150 size_t listSize = negZOrderList->size();
1105 for (size_t i = 0; i < listSize; ++i) { 1151 for (size_t i = 0; i < listSize; ++i) {
1106 RenderLayer* curLayer = negZOrderList->at(i); 1152 RenderLayer* curLayer = negZOrderList->at(i);
1107 rebuildCompositingLayerTree(curLayer, childList, depth + 1); 1153 rebuildCompositingLayerTreeForLayerAndScrollParents(curLayer, ch ildList, visited, scrollParentChildLists, depth + 1);
1108 } 1154 }
1109 } 1155 }
1110 1156
1111 // If a negative z-order child is compositing, we get a foreground layer which needs to get parented. 1157 // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
1112 if (layerBacking && layerBacking->foregroundLayer()) 1158 if (layerBacking && layerBacking->foregroundLayer())
1113 childList.append(layerBacking->foregroundLayer()); 1159 childList.append(layerBacking->foregroundLayer());
1114 } 1160 }
1115 1161
1116 if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) { 1162 childList.append(normalFlowChildList);
1117 size_t listSize = normalFlowList->size();
1118 for (size_t i = 0; i < listSize; ++i) {
1119 RenderLayer* curLayer = normalFlowList->at(i);
1120 rebuildCompositingLayerTree(curLayer, childList, depth + 1);
1121 }
1122 }
1123 1163
1124 if (layer->isStackingContainer()) { 1164 if (layer->isStackingContainer()) {
1125 if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) { 1165 if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1126 size_t listSize = posZOrderList->size(); 1166 size_t listSize = posZOrderList->size();
1127 for (size_t i = 0; i < listSize; ++i) { 1167 for (size_t i = 0; i < listSize; ++i) {
1128 RenderLayer* curLayer = posZOrderList->at(i); 1168 RenderLayer* curLayer = posZOrderList->at(i);
1129 rebuildCompositingLayerTree(curLayer, childList, depth + 1); 1169 rebuildCompositingLayerTreeForLayerAndScrollParents(curLayer, ch ildList, visited, scrollParentChildLists, depth + 1);
1130 } 1170 }
1131 } 1171 }
1132 } 1172 }
1133 1173
1134 if (layerBacking) { 1174 if (layerBacking) {
1135 bool parented = false; 1175 bool parented = false;
1136 if (layer->renderer()->isRenderPart()) 1176 if (layer->renderer()->isRenderPart())
1137 parented = parentFrameContentLayers(toRenderPart(layer->renderer())) ; 1177 parented = parentFrameContentLayers(toRenderPart(layer->renderer())) ;
1138 1178
1139 if (!parented) 1179 if (!parented)
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after
1300 RenderLayerBacking* backing = layer->backing(); 1340 RenderLayerBacking* backing = layer->backing();
1301 GraphicsLayer* hostingLayer = backing->parentForSublayers(); 1341 GraphicsLayer* hostingLayer = backing->parentForSublayers();
1302 GraphicsLayer* rootLayer = innerCompositor->rootGraphicsLayer(); 1342 GraphicsLayer* rootLayer = innerCompositor->rootGraphicsLayer();
1303 if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != r ootLayer) { 1343 if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != r ootLayer) {
1304 hostingLayer->removeAllChildren(); 1344 hostingLayer->removeAllChildren();
1305 hostingLayer->addChild(rootLayer); 1345 hostingLayer->addChild(rootLayer);
1306 } 1346 }
1307 return true; 1347 return true;
1308 } 1348 }
1309 1349
1350 void RenderLayerCompositor::updateLayerTreeGeometryForLayerAndScrollParents(Rend erLayer* layer, HashSet<RenderLayer*>& visited, int depth)
1351 {
1352 ASSERT(layer->zIndex() >= 0 || !visited.contains(layer));
1353 if (visited.contains(layer))
1354 return;
1355
1356 if (requiresCompositingForOverflowScrollingParent(layer)) {
1357 RenderLayer* scrollParent = layer->ancestorScrollingLayer();
1358 if (!visited.contains(scrollParent))
1359 updateLayerTreeGeometryForLayerAndScrollParents(scrollParent, visite d, depth);
1360 }
1361
1362 updateLayerTreeGeometry(layer, visited, depth);
1363 }
1310 // This just updates layer geometry without changing the hierarchy. 1364 // This just updates layer geometry without changing the hierarchy.
1311 void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer* layer, int dept h) 1365 void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer* layer, HashSet< RenderLayer*>& visited, int depth)
1312 { 1366 {
1367 visited.add(layer);
1368
1313 if (RenderLayerBacking* layerBacking = layer->backing()) { 1369 if (RenderLayerBacking* layerBacking = layer->backing()) {
1314 // The compositing state of all our children has been updated already, s o now 1370 // The compositing state of all our children has been updated already, s o now
1315 // we can compute and cache the composited bounds for this layer. 1371 // we can compute and cache the composited bounds for this layer.
1316 layerBacking->updateCompositedBounds(); 1372 layerBacking->updateCompositedBounds();
1317 1373
1318 if (RenderLayer* reflection = layer->reflectionLayer()) { 1374 if (RenderLayer* reflection = layer->reflectionLayer()) {
1319 if (reflection->backing()) 1375 if (reflection->backing())
1320 reflection->backing()->updateCompositedBounds(); 1376 reflection->backing()->updateCompositedBounds();
1321 } 1377 }
1322 1378
1323 layerBacking->updateGraphicsLayerConfiguration(); 1379 layerBacking->updateGraphicsLayerConfiguration();
1324 layerBacking->updateGraphicsLayerGeometry(); 1380 layerBacking->updateGraphicsLayerGeometry();
1325 1381
1326 if (!layer->parent()) 1382 if (!layer->parent())
1327 updateRootLayerPosition(); 1383 updateRootLayerPosition();
1328 1384
1329 #if !LOG_DISABLED 1385 #if !LOG_DISABLED
1330 logLayerInfo(layer, depth); 1386 logLayerInfo(layer, depth);
1331 #else 1387 #else
1332 UNUSED_PARAM(depth); 1388 UNUSED_PARAM(depth);
1333 #endif 1389 #endif
1334 } 1390 }
1335 1391
1336 #if !ASSERT_DISABLED 1392 #if !ASSERT_DISABLED
1337 LayerListMutationDetector mutationChecker(layer); 1393 LayerListMutationDetector mutationChecker(layer);
1338 #endif 1394 #endif
1339 1395
1396 if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1397 size_t listSize = normalFlowList->size();
1398 for (size_t i = 0; i < listSize; ++i)
1399 updateLayerTreeGeometry(normalFlowList->at(i), visited, depth + 1);
1400 }
1401
1340 if (layer->isStackingContainer()) { 1402 if (layer->isStackingContainer()) {
1341 if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) { 1403 if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1342 size_t listSize = negZOrderList->size(); 1404 size_t listSize = negZOrderList->size();
1343 for (size_t i = 0; i < listSize; ++i) 1405 for (size_t i = 0; i < listSize; ++i)
1344 updateLayerTreeGeometry(negZOrderList->at(i), depth + 1); 1406 updateLayerTreeGeometryForLayerAndScrollParents(negZOrderList->a t(i), visited, depth + 1);
1345 } 1407 }
1346 } 1408 }
1347 1409
1348 if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1349 size_t listSize = normalFlowList->size();
1350 for (size_t i = 0; i < listSize; ++i)
1351 updateLayerTreeGeometry(normalFlowList->at(i), depth + 1);
1352 }
1353
1354 if (layer->isStackingContainer()) { 1410 if (layer->isStackingContainer()) {
1355 if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) { 1411 if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1356 size_t listSize = posZOrderList->size(); 1412 size_t listSize = posZOrderList->size();
1357 for (size_t i = 0; i < listSize; ++i) 1413 for (size_t i = 0; i < listSize; ++i)
1358 updateLayerTreeGeometry(posZOrderList->at(i), depth + 1); 1414 updateLayerTreeGeometryForLayerAndScrollParents(posZOrderList->a t(i), visited, depth + 1);
1359 } 1415 }
1360 } 1416 }
1361 } 1417 }
1362 1418
1363 // Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry. 1419 // Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry.
1364 void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayer* com positingAncestor, RenderLayer* layer, bool compositedChildrenOnly) 1420 void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayer* com positingAncestor, RenderLayer* layer, bool compositedChildrenOnly)
1365 { 1421 {
1366 if (layer != compositingAncestor) { 1422 if (layer != compositingAncestor) {
1367 if (RenderLayerBacking* layerBacking = layer->backing()) { 1423 if (RenderLayerBacking* layerBacking = layer->backing()) {
1368 layerBacking->updateCompositedBounds(); 1424 layerBacking->updateCompositedBounds();
(...skipping 375 matching lines...) Expand 10 before | Expand all | Expand 10 after
1744 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips, 1800 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
1745 // up to the enclosing compositing ancestor. This is required because compositin g layers are parented 1801 // up to the enclosing compositing ancestor. This is required because compositin g layers are parented
1746 // according to the z-order hierarchy, yet clipping goes down the renderer hiera rchy. 1802 // according to the z-order hierarchy, yet clipping goes down the renderer hiera rchy.
1747 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in th e renderer hierarchy, 1803 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in th e renderer hierarchy,
1748 // but a sibling in the z-order hierarchy. 1804 // but a sibling in the z-order hierarchy.
1749 bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const 1805 bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const
1750 { 1806 {
1751 if (!layer->isComposited() || !layer->parent()) 1807 if (!layer->isComposited() || !layer->parent())
1752 return false; 1808 return false;
1753 1809
1754 RenderLayer* compositingAncestor = layer->ancestorCompositingLayer(); 1810 // Scroll children use their scrolling ancestor as their clip root.
1811 RenderLayer* compositingAncestor = requiresCompositingForOverflowScrollingPa rent(layer)
1812 ? layer->ancestorScrollingLayer()
1813 : layer->ancestorCompositingLayer();
1814
1755 if (!compositingAncestor) 1815 if (!compositingAncestor)
1756 return false; 1816 return false;
1757 1817
1758 // If the compositingAncestor clips, that will be taken care of by clipsComp ositingDescendants(), 1818 // If the compositingAncestor clips, that will be taken care of by clipsComp ositingDescendants(),
1759 // so we only care about clipping between its first child that is our ancest or (the computeClipRoot), 1819 // so we only care about clipping between its first child that is our ancest or (the computeClipRoot),
1760 // and layer. 1820 // and layer.
1761 RenderLayer* computeClipRoot = 0; 1821 RenderLayer* computeClipRoot = 0;
1762 RenderLayer* curr = layer; 1822 RenderLayer* curr = layer;
1763 while (curr) { 1823 while (curr) {
1764 RenderLayer* next = curr->parent(); 1824 RenderLayer* next = curr->parent();
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after
1966 return renderer->hasFilter(); 2026 return renderer->hasFilter();
1967 } 2027 }
1968 2028
1969 bool RenderLayerCompositor::requiresCompositingForBlending(RenderObject* rendere r) const 2029 bool RenderLayerCompositor::requiresCompositingForBlending(RenderObject* rendere r) const
1970 { 2030 {
1971 return renderer->hasBlendMode(); 2031 return renderer->hasBlendMode();
1972 } 2032 }
1973 2033
1974 bool RenderLayerCompositor::requiresCompositingForOverflowScrollingParent(const RenderLayer* layer) const 2034 bool RenderLayerCompositor::requiresCompositingForOverflowScrollingParent(const RenderLayer* layer) const
1975 { 2035 {
1976 if (!layer->useCompositorDrivenAcceleratedScrolling()) 2036 return layer->hasScrollParent();
1977 return false;
1978
1979 // A layer scrolls with its containing block. So to find the overflow scroll ing layer
1980 // that we scroll with respect to, we must ascend the layer tree until we re ach the
1981 // first overflow scrolling div at or above our containing block. I will ref er to this
1982 // layer as our 'scrolling ancestor'.
1983 //
1984 // Now, if we reside in a normal flow list, then we will naturally scroll wi th our scrolling
1985 // ancestor, and we need not be composited. If, on the other hand, we reside in a z-order
1986 // list, and on our walk upwards to our scrolling ancestor we find no layer that is a stacking
1987 // context, then we know that in the stacking tree, we will not be in the su btree rooted at
1988 // our scrolling ancestor, and we will therefore not scroll with it. In this case, we must
1989 // be a composited layer since the compositor will need to take special meas ures to ensure
1990 // that we scroll with our scrolling ancestor and it cannot do this if we do not promote.
1991 RenderLayer* scrollParent = layer->ancestorScrollingLayer();
1992
1993 if (!scrollParent || scrollParent->isStackingContext())
1994 return false;
1995
1996 // If we hit a stacking context on our way up to the ancestor scrolling laye r, it will already
1997 // be composited due to an overflow scrolling parent, so we don't need to.
1998 for (RenderLayer* ancestor = layer->parent(); ancestor && ancestor != scroll Parent; ancestor = ancestor->parent()) {
1999 if (ancestor->isStackingContext())
2000 return false;
2001 }
2002
2003 return true;
2004 } 2037 }
2005 2038
2006 bool RenderLayerCompositor::requiresCompositingForOutOfFlowClipping(const Render Layer* layer) const 2039 bool RenderLayerCompositor::requiresCompositingForOutOfFlowClipping(const Render Layer* layer) const
2007 { 2040 {
2008 return layer->compositorDrivenAcceleratedScrollingEnabled() && layer->isUncl ippedDescendant(); 2041 return layer->compositorDrivenAcceleratedScrollingEnabled() && layer->isUncl ippedDescendant();
2009 } 2042 }
2010 2043
2011 bool RenderLayerCompositor::requiresCompositingForPosition(RenderObject* rendere r, const RenderLayer* layer, RenderLayer::ViewportConstrainedNotCompositedReason * viewportConstrainedNotCompositedReason) const 2044 bool RenderLayerCompositor::requiresCompositingForPosition(RenderObject* rendere r, const RenderLayer* layer, RenderLayer::ViewportConstrainedNotCompositedReason * viewportConstrainedNotCompositedReason) const
2012 { 2045 {
2013 // position:fixed elements that create their own stacking context (e.g. have an explicit z-index, 2046 // position:fixed elements that create their own stacking context (e.g. have an explicit z-index,
(...skipping 714 matching lines...) Expand 10 before | Expand all | Expand 10 after
2728 } else if (graphicsLayer == m_scrollLayer.get()) { 2761 } else if (graphicsLayer == m_scrollLayer.get()) {
2729 name = "Frame Scrolling Layer"; 2762 name = "Frame Scrolling Layer";
2730 } else { 2763 } else {
2731 ASSERT_NOT_REACHED(); 2764 ASSERT_NOT_REACHED();
2732 } 2765 }
2733 2766
2734 return name; 2767 return name;
2735 } 2768 }
2736 2769
2737 } // namespace WebCore 2770 } // namespace WebCore
OLDNEW
« no previous file with comments | « Source/core/rendering/RenderLayerCompositor.h ('k') | public/platform/WebLayer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698