Snap for 13259233 from b7786300 to 25Q3-release

                }

            }

            val shouldAddToCache =

                !(lookupFlags.skipAddToMemCache() && Flags.restoreArchivedAppIconsFromDb())

            // Only add a filled-out entry to the cache

            if (entryUpdated) {

            if (entryUpdated && shouldAddToCache) {

                cache[cacheKey] = entry

            }

        }

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools">

    <!--

      Important: disable debugging for accurate performance results

      In a com.android.library project, this flag must be disabled from this

      manifest, as it is not possible to override this flag from Gradle.

    -->

    <application

        android:debuggable="false"

        tools:ignore="HardcodedDebugMode"

        tools:replace="android:debuggable" />

</manifest>

 No newline at end of file

# Add project specific ProGuard rules here.

# You can control the set of applied configuration files using the

# proguardFiles setting in build.gradle.

#

# For more details, see

#   http://developer.android.com/guide/developing/tools/proguard.html

# If your project uses WebView with JS, uncomment the following

# and specify the fully qualified class name to the JavaScript interface

# class:

#-keepclassmembers class fqcn.of.javascript.interface.for.webview {

#   public *;

#}

# Uncomment this to preserve the line number information for

# debugging stack traces.

#-keepattributes SourceFile,LineNumberTable

# If you keep the line number information, uncomment this to

# hide the original source file name.

#-renamesourcefileattribute SourceFile

-dontobfuscate

-ignorewarnings

-keepattributes *Annotation*

-dontnote junit.framework.**

-dontnote junit.runner.**

-dontwarn androidx.test.**

-dontwarn org.junit.**

-dontwarn org.hamcrest.**

-dontwarn com.squareup.javawriter.JavaWriter

-keepclasseswithmembers @org.junit.runner.RunWith public class *

 No newline at end of file

/*

 * Copyright (C) 2025 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.mechanics.benchmark

import androidx.benchmark.junit4.BenchmarkRule

import androidx.benchmark.junit4.measureRepeated

import androidx.compose.runtime.mutableFloatStateOf

import androidx.test.ext.junit.runners.AndroidJUnit4

import com.android.mechanics.DistanceGestureContext

import com.android.mechanics.MotionValue

import com.android.mechanics.spec.InputDirection

import org.junit.Rule

import org.junit.Test

import org.junit.runner.RunWith

/** Benchmark, which will execute on an Android device. Previous results: go/mm-microbenchmarks */

@RunWith(AndroidJUnit4::class)

class MotionValueBenchmark {

    @get:Rule val benchmarkRule = BenchmarkRule()

    @Test

    fun createMotionValue() {

        val gestureContext = DistanceGestureContext(0f, InputDirection.Max, 2f)

        val currentInput = { 0f }

        benchmarkRule.measureRepeated { MotionValue(currentInput, gestureContext) }

    }

    @Test

    fun changeInput_readOutput() {

        val gestureContext = DistanceGestureContext(0f, InputDirection.Max, 2f)

        val a = mutableFloatStateOf(0f)

        val motionValue = MotionValue(a::floatValue, gestureContext)

        benchmarkRule.measureRepeated {

            runWithMeasurementDisabled { a.floatValue += 1f }

            motionValue.floatValue

        }

    }

    @Test

    fun readOutputMultipleTimes() {

        val gestureContext = DistanceGestureContext(0f, InputDirection.Max, 2f)

        val a = mutableFloatStateOf(0f)

        val motionValue = MotionValue(a::floatValue, gestureContext)

        benchmarkRule.measureRepeated {

            runWithMeasurementDisabled {

                a.floatValue += 1f

                motionValue.output

            }

            motionValue.output

        }

    }

    @Test

    fun readOutputMultipleTimesMeasureAll() {

        val gestureContext = DistanceGestureContext(0f, InputDirection.Max, 2f)

        val currentInput = mutableFloatStateOf(0f)

        val motionValue = MotionValue(currentInput::floatValue, gestureContext)

        benchmarkRule.measureRepeated {

            currentInput.floatValue += 1f

            motionValue.output

            motionValue.output

        }

    }

}

    private boolean mIsEnabled = true;

    @VisibleForTesting

    public boolean mIsStarted = false;

    protected ViewCapture(int memorySize, int initPoolSize, Executor bgExecutor) {

        mMemorySize = memorySize;

        mBgExecutor = bgExecutor;

    @AnyThread

    @NonNull

    public SafeCloseable startCapture(@NonNull View view, @NonNull String name) {

        mIsStarted = true;

        WindowListener listener = new WindowListener(view, name);

        if (mIsEnabled) {

        mListeners.add(listener);

        runOnUiThread(() -> view.getContext().registerComponentCallbacks(listener), view);

        view.getContext().registerComponentCallbacks(listener);

        return () -> {

            if (listener.mRoot != null && listener.mRoot.getContext() != null) {

    @VisibleForTesting

    @AnyThread

    public void stopCapture(@NonNull View rootView) {

        mIsStarted = false;

        mListeners.forEach(it -> {

            if (rootView == it.mRoot) {

                runOnUiThread(() -> {