Revert "CacheWindow refill update #2"

This reverts commit fdc614d.

Reason for revert: broke g3

Change-Id: I932d0f0d2ff42cb8ae7342a3d3d65ada1891681d

Author: Levi-Moreira

compose/foundation/foundation/integration-tests/lazy-tests/src/androidTest/kotlin/androidx/compose/foundation/lazy/list/LazyListCacheWindowTest.kt

@@ -185,7 +185,7 @@ class LazyListCacheWindowTest(orientation: Orientation) :
     }
 
     @Test
-    fun datasetChanged_shouldMakeSureNestedItemsChanged_afterScroll() {
+    fun datasetChanged_shouldMakeSureNestedItemsChanged() {
         val items = mutableStateOf(listOf("a", "b", "c", "d", "e"))
 
         rule.setContent {
@@ -264,80 +264,6 @@ class LazyListCacheWindowTest(orientation: Orientation) :
         rule.onNodeWithTag("second-nested-e").assertExists() // nested prefetched
     }
 
-    @Test
-    fun datasetChanged_shouldMakeSureNestedItemsChanged_noScroll() {
-        val items = mutableStateOf(listOf("a", "b", "c", "d"))
-
-        rule.setContent {
-            @OptIn(ExperimentalFoundationApi::class)
-            state = rememberLazyListState(cacheWindow = viewportWindow)
-            LazyColumnOrRow(
-                Modifier.mainAxisSize(itemsSizeDp * 2f)
-                    .then(
-                        object : RemeasurementModifier {
-                            override fun onRemeasurementAvailable(remeasurement: Remeasurement) {
-                                remeasure = remeasurement
-                            }
-                        }
-                    ),
-                state,
-            ) {
-                items(items.value, key = { it }) {
-                    if (it == "e" || it == "f") {
-                        val state = rememberLazyListState(cacheWindow = viewportWindow)
-                        LazyRow(
-                            Modifier.mainAxisSize(itemsSizeDp).fillMaxCrossAxis().testTag(it),
-                            state = state,
-                        ) {
-                            item {
-                                Spacer(
-                                    Modifier.mainAxisSize(itemsSizeDp)
-                                        .fillMaxCrossAxis()
-                                        .testTag("first-nested-$it")
-                                )
-                            }
-
-                            item {
-                                Spacer(
-                                    Modifier.mainAxisSize(itemsSizeDp)
-                                        .fillMaxCrossAxis()
-                                        .testTag("second-nested-$it")
-                                )
-                            }
-                        }
-                    } else {
-                        Spacer(
-                            Modifier.mainAxisSize(itemsSizeDp)
-                                .fillMaxCrossAxis()
-                                .testTag(it)
-                                .layout { measurable, constraints ->
-                                    val placeable = measurable.measure(constraints)
-                                    layout(placeable.width, placeable.height) {
-                                        placeable.place(0, 0)
-                                    }
-                                }
-                        )
-                    }
-                }
-            }
-        }
-
-        rule.onNodeWithTag("a").assertIsDisplayed() // fully visible
-        rule.onNodeWithTag("b").assertIsDisplayed() // fully visible
-        rule.onNodeWithTag("c").assertExists() // part of the window
-        rule.onNodeWithTag("d").assertExists() // part of the window
-        println("Changing Dataset")
-        rule.runOnIdle { items.value = listOf("a", "b", "e", "f", "g", "h") }
-        rule.waitForIdle()
-
-        rule.onNodeWithTag("e").assertExists() // item e will take place of item c
-        rule.onNodeWithTag("first-nested-e").assertExists() // nested prefetched
-        rule.onNodeWithTag("second-nested-e").assertExists() // nested prefetched
-        rule.onNodeWithTag("f").assertExists() // item f will take place of item d
-        rule.onNodeWithTag("first-nested-f").assertExists() // nested prefetched
-        rule.onNodeWithTag("second-nested-f").assertExists() // nested prefetched
-    }
-
     @Test
     fun datasetChanged_noScrollHappened_shouldKeepAroundWithinBounds_notCrash() {
         val numItems = mutableStateOf(100)

compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/lazy/LazyListCacheWindowStrategy.kt

@@ -135,10 +135,6 @@ internal class LazyListCacheWindowScope() : CacheWindowScope {
 
     override fun getLastIndexInLine(lineIndex: Int): Int = lineIndex
 
-    override fun getVisibleLineKey(indexInVisibleLines: Int): Any {
-        return layoutInfo.visibleItemsInfo[indexInVisibleLines].key
-    }
-
     override fun getLastLineIndex(): Int {
         if (totalItemsCount == 0) return InvalidIndex
         return totalItemsCount - 1

compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/lazy/grid/LazyGridCacheWindowStrategy.kt

@@ -21,7 +21,6 @@ import androidx.compose.foundation.gestures.snapping.offsetOnMainAxis
 import androidx.compose.foundation.gestures.snapping.sizeOnMainAxis
 import androidx.compose.foundation.lazy.layout.CacheWindowLogic
 import androidx.compose.foundation.lazy.layout.CacheWindowScope
-import androidx.compose.foundation.lazy.layout.CachedItem
 import androidx.compose.foundation.lazy.layout.InvalidIndex
 import androidx.compose.foundation.lazy.layout.LazyLayoutCacheWindow
 import androidx.compose.foundation.lazy.layout.LazyLayoutPrefetchState.PrefetchHandle
@@ -138,15 +137,6 @@ private class LazyGridCacheWindowScope() : CacheWindowScope {
         return tallestItemSize
     }
 
-    override fun getVisibleLineKey(indexInVisibleLines: Int): Any {
-        // using the first item key to represent this line.
-        val laneIndex = indexInVisibleLines + firstVisibleLineIndex
-        return layoutInfo.visibleItemsInfo
-            .fastFilter { it.lineIndex == laneIndex }
-            .firstOrNull()
-            ?.key ?: CachedItem.NoKey
-    }
-
     override fun getVisibleItemLine(indexInVisibleLines: Int): Int =
         firstVisibleLineIndex + indexInVisibleLines
 

compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/lazy/layout/CacheWindowLogic.kt

@@ -16,6 +16,7 @@
 
 package androidx.compose.foundation.lazy.layout
 
+import androidx.collection.mutableIntIntMapOf
 import androidx.collection.mutableIntObjectMapOf
 import androidx.collection.mutableIntSetOf
 import androidx.compose.foundation.ExperimentalFoundationApi
@@ -42,7 +43,7 @@ internal abstract class CacheWindowLogic(
      * Cache for items sizes in the current window. Holds sizes for both visible and non-visible
      * items
      */
-    private val windowCache = mutableIntObjectMapOf<CachedItem>()
+    private val windowCache = mutableIntIntMapOf()
     private var previousPassDelta = 0f
     private var previousPassItemCount = UnsetItemCount
     private var hasUpdatedVisibleItemsOnce = false
@@ -119,7 +120,15 @@ internal abstract class CacheWindowLogic(
          * changed.
          */
         if (previousPassItemCount != UnsetItemCount && previousPassItemCount != totalItemsCount) {
-            onDatasetChangedSize()
+            debugLog { "Total Items Changed" }
+            shouldRefillWindow = true
+            prefetchWindowStartLine = prefetchWindowStartLine.coerceAtLeast(0)
+            val lastLineIndex = getLastLineIndex()
+            if (lastLineIndex != InvalidIndex) {
+                prefetchWindowEndLine = prefetchWindowEndLine.coerceAtMost(lastLineIndex)
+            }
+            /** Free up the space so the fill will happen and not re-use old data. */
+            removeOutOfBoundsItems(prefetchWindowEndLine, itemsCount - 1)
         }
 
         itemsCount = totalItemsCount
@@ -128,8 +137,8 @@ internal abstract class CacheWindowLogic(
         // by [cancelOutOfBounds]. If any items changed sizes we re-trigger the window filling
         // update.
         if (hasVisibleItems) {
-            forEachVisibleItem { index, key, mainAxisSize ->
-                if (index != InvalidIndex) cacheVisibleItemsInfo(index, key, mainAxisSize)
+            forEachVisibleItem { index, mainAxisSize ->
+                if (index != InvalidIndex) cacheVisibleItemsInfo(index, mainAxisSize)
             }
             if (shouldRefillWindow) {
                 // refill window in accordance with last pass delta
@@ -225,25 +234,6 @@ internal abstract class CacheWindowLogic(
         }
     }
 
-    private fun CacheWindowScope.onDatasetChangedSize() {
-        debugLog { "Total Items Changed" }
-        shouldRefillWindow = true
-        prefetchWindowStartLine = prefetchWindowStartLine.coerceAtLeast(0)
-        val lastLineIndex = getLastLineIndex()
-        if (lastLineIndex != InvalidIndex) {
-            prefetchWindowEndLine = prefetchWindowEndLine.coerceAtMost(lastLineIndex)
-        }
-
-        /**
-         * Resets the window state. We will refill the window on the direction of the last scroll.
-         */
-        if (previousPassDelta <= 0f) {
-            removeOutOfBoundsItems(lastVisibleLineIndex, itemsCount - 1)
-        } else {
-            removeOutOfBoundsItems(0, firstVisibleLineIndex)
-        }
-    }
-
     fun resetStrategy() {
         prefetchWindowStartLine = Int.MAX_VALUE
         prefetchWindowEndLine = Int.MIN_VALUE
@@ -293,7 +283,7 @@ internal abstract class CacheWindowLogic(
                 // If we get the same delta in the next frame, would we cover the extra space needed
                 // to actually need this item? If so, mark it as urgent
                 val isUrgent: Boolean =
-                    if (prefetchWindowEndLine + 1 == visibleWindowEnd + 1 && scrollDelta != 0.0f) {
+                    if (prefetchWindowEndLine + 1 == visibleWindowEnd + 1) {
                         scrollDelta.absoluteValue >= mainAxisExtraSpaceEnd
                     } else {
                         false
@@ -325,9 +315,7 @@ internal abstract class CacheWindowLogic(
                 // If we get the same delta in the next frame, would we cover the extra space needed
                 // to actually need this item? If so, mark it as urgent
                 val isUrgent: Boolean =
-                    if (
-                        prefetchWindowStartLine - 1 == visibleWindowStart - 1 && scrollDelta != 0.0f
-                    ) {
+                    if (prefetchWindowStartLine - 1 == visibleWindowStart - 1) {
                         scrollDelta.absoluteValue >= mainAxisExtraSpaceStart
                     } else {
                         false
@@ -370,7 +358,7 @@ internal abstract class CacheWindowLogic(
             while (prefetchWindowStartExtraSpace > 0 && prefetchWindowStartLine > 0) {
                 val item =
                     if (windowCache.containsKey(prefetchWindowStartLine - 1)) {
-                        windowCache[prefetchWindowStartLine - 1]!!.mainAxisSize
+                        windowCache[prefetchWindowStartLine - 1]
                     } else {
                         break
                     }
@@ -385,7 +373,7 @@ internal abstract class CacheWindowLogic(
             while (prefetchWindowEndExtraSpace > 0 && prefetchWindowEndLine < itemsCount - 1) {
                 val item =
                     if (windowCache.containsKey(prefetchWindowEndLine + 1)) {
-                        windowCache[prefetchWindowEndLine + 1]!!.mainAxisSize
+                        windowCache[prefetchWindowEndLine + 1]
                     } else {
                         break
                     }
@@ -398,16 +386,13 @@ internal abstract class CacheWindowLogic(
 
     private fun CacheWindowScope.getItemSizeOrPrefetch(index: Int, isUrgent: Boolean): Int {
         return if (windowCache.containsKey(index)) {
-            debugLog { "Item $index is Cached!" }
-            windowCache[index]!!.mainAxisSize
+            windowCache[index]
         } else if (prefetchWindowHandles.containsKey(index)) {
             // item is scheduled but didn't finish yet
-            debugLog { "Item=$index is already scheduled. isUrgent=$isUrgent" }
             if (isUrgent) prefetchWindowHandles[index]?.fastForEach { it.markAsUrgent() }
             InvalidItemSize
         } else {
             // item is not scheduled
-            debugLog { "Scheduling Prefetching for Item=$index. isUrgent=$isUrgent" }
             prefetchWindowHandles[index] =
                 schedulePrefetch(index) { prefetchedIndex, size ->
                     onItemPrefetched(prefetchedIndex, size)
@@ -419,7 +404,7 @@ internal abstract class CacheWindowLogic(
 
     /** Grows the window with measured items and prefetched items. */
     private fun cachePrefetchedItem(index: Int, size: Int) {
-        windowCache[index] = updateOrCreateCachedItem(index, size, CachedItem.NoKey)
+        windowCache[index] = size
         if (index > prefetchWindowEndLine) {
             prefetchWindowEndLine = index
             prefetchWindowEndExtraSpace -= size
@@ -429,34 +414,18 @@ internal abstract class CacheWindowLogic(
         }
     }
 
-    private fun updateOrCreateCachedItem(index: Int, size: Int, key: Any): CachedItem {
-        val cachedItem = windowCache[index]
-        return if (cachedItem != null) {
-            cachedItem.mainAxisSize = size
-            cachedItem.key = key
-            cachedItem
-        } else {
-            CachedItem(CachedItem.NoKey, size)
-        }
-    }
-
     /**
      * When caching visible items we need to check if the existing item changed sizes. If so, we
      * will set [shouldRefillWindow] which will trigger a complete window filling and cancel any out
-     * of bounds requests. The same is valid if items are replaced (have the same size by key
-     * changed).
+     * of bounds requests.
      */
-    private fun cacheVisibleItemsInfo(index: Int, key: Any, size: Int) {
-        debugLog { "cacheVisibleItemsInfo item=$index size=$size key=$key" }
-        if (windowCache.containsKey(index)) {
-            val cachedSize = windowCache[index]!!.mainAxisSize
-            val cachedKey = windowCache[index]!!.key
-            if (cachedSize != size || cachedKey != key) {
-                shouldRefillWindow = true
-            }
+    private fun cacheVisibleItemsInfo(index: Int, size: Int) {
+        debugLog { "cacheVisibleItemsInfo item=$index size=$size" }
+        if (windowCache.containsKey(index) && windowCache[index] != size) {
+            shouldRefillWindow = true
         }
 
-        windowCache[index] = updateOrCreateCachedItem(index, size, key)
+        windowCache[index] = size
         // We're caching a visible item, remove its handle since we won't need it anymore.
         prefetchWindowStartLine = minOf(prefetchWindowStartLine, index)
         prefetchWindowEndLine = maxOf(prefetchWindowEndLine, index)
@@ -470,8 +439,6 @@ internal abstract class CacheWindowLogic(
 
         windowCache.forEachKey { if (it in startLine..endLine) indicesToRemove.add(it) }
 
-        debugLog { "Indices to remove=$indicesToRemove" }
-
         indicesToRemove.forEach {
             prefetchWindowHandles.remove(it)?.fastForEach { it.cancel() }
             windowCache.remove(it)
@@ -534,19 +501,15 @@ internal interface CacheWindowScope {
 
     fun getVisibleItemLine(indexInVisibleLines: Int): Int
 
-    fun getVisibleLineKey(indexInVisibleLines: Int): Any
-
     fun getLastIndexInLine(lineIndex: Int): Int
 
     fun getLastLineIndex(): Int
 }
 
 internal inline fun CacheWindowScope.forEachVisibleItem(
-    action: (itemIndex: Int, itemKey: Any, mainAxisSize: Int) -> Unit
+    action: (itemIndex: Int, mainAxisSize: Int) -> Unit
 ) {
-    repeat(visibleLineCount) {
-        action(getVisibleItemLine(it), getVisibleLineKey(it), getVisibleItemSize(it))
-    }
+    repeat(visibleLineCount) { action(getVisibleItemLine(it), getVisibleItemSize(it)) }
 }
 
 private const val InvalidItemSize = -1
@@ -560,7 +523,3 @@ private inline fun debugLog(generateMsg: () -> String) {
         println("CacheWindowLogic: ${generateMsg()}")
     }
 }
-
-internal class CachedItem(var key: Any, var mainAxisSize: Int) {
-    companion object NoKey
-}

compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/pager/PagerCacheWindowLogic.kt

@@ -19,7 +19,6 @@ package androidx.compose.foundation.pager
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.lazy.layout.CacheWindowLogic
 import androidx.compose.foundation.lazy.layout.CacheWindowScope
-import androidx.compose.foundation.lazy.layout.CachedItem
 import androidx.compose.foundation.lazy.layout.InvalidIndex
 import androidx.compose.foundation.lazy.layout.LazyLayoutCacheWindow
 import androidx.compose.foundation.lazy.layout.LazyLayoutPrefetchState
@@ -157,30 +156,6 @@ private class PagerCacheWindowScope(val itemCount: () -> Int) : CacheWindowScope
         return InvalidIndex
     }
 
-    override fun getVisibleLineKey(indexInVisibleLines: Int): Any {
-        val extraPagesBeforeCount = layoutInfo.extraPagesBefore.size
-
-        val visiblePagesCount = layoutInfo.visiblePagesInfo.size
-
-        if (indexInVisibleLines < extraPagesBeforeCount) {
-            return layoutInfo.extraPagesBefore[indexInVisibleLines].key
-        }
-
-        if (
-            indexInVisibleLines >= extraPagesBeforeCount &&
-                indexInVisibleLines < extraPagesBeforeCount + visiblePagesCount
-        ) {
-            return layoutInfo.visiblePagesInfo[indexInVisibleLines - extraPagesBeforeCount].key
-        }
-
-        if (indexInVisibleLines >= extraPagesBeforeCount + visiblePagesCount) {
-            return layoutInfo.extraPagesAfter[
-                    indexInVisibleLines - extraPagesBeforeCount - visiblePagesCount]
-                .key
-        }
-        return CachedItem.NoKey
-    }
-
     override fun getLastIndexInLine(lineIndex: Int): Int = lineIndex
 
     override fun getLastLineIndex(): Int {