Merge "Adopt LruCache in SettingsProvider."

package com.android.providers.settings;

import java.io.FileNotFoundException;

import java.io.UnsupportedEncodingException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicInteger;

import android.provider.Settings;

import android.text.TextUtils;

import android.util.Log;

import android.util.LruCache;

public class SettingsProvider extends ContentProvider {

    private static final String TAG = "SettingsProvider";

            "" + (MAX_CACHE_ENTRIES + 1) /* limit */);

        try {

            synchronized (cache) {

                cache.clear();

                cache.evictAll();

                cache.setFullyMatchesDisk(true);  // optimistic

                int rows = 0;

                while (c.moveToNext()) {

    // possibly with a null value, or null on failure.

    private Bundle lookupValue(String table, SettingsCache cache, String key) {

        synchronized (cache) {

            if (cache.containsKey(key)) {

            Bundle value = cache.get(key);

            if (value != null) {

                if (value != TOO_LARGE_TO_CACHE_MARKER) {

                    return value;

                }

     * associated helper functions to keep cache coherent with the

     * database.

     */

    private static final class SettingsCache extends LinkedHashMap<String, Bundle> {

    private static final class SettingsCache extends LruCache<String, Bundle> {

        private final String mCacheName;

        private boolean mCacheFullyMatchesDisk = false;  // has the whole database slurped.

        public SettingsCache(String name) {

            super(MAX_CACHE_ENTRIES, 0.75f /* load factor */, true /* access ordered */);

            super(MAX_CACHE_ENTRIES);

            mCacheName = name;

        }

        }

        @Override

        protected boolean removeEldestEntry(Map.Entry eldest) {

            if (size() <= MAX_CACHE_ENTRIES) {

                return false;

            }

            synchronized (this) {

        protected synchronized void entryEvicted(String key, Bundle value) {

            mCacheFullyMatchesDisk = false;

        }

            return true;

        }

        /**

         * Atomic cache population, conditional on size of value and if

            Bundle bundle = (value == null) ? NULL_SETTING : Bundle.forPair("value", value);

            if (value == null || value.length() <= MAX_CACHE_ENTRY_SIZE) {

                synchronized (this) {

                    if (!containsKey(key)) {

                    if (get(key) == null) {

                        put(key, bundle);

                    }

                }

                return;

            }

            synchronized (cache) {

                cache.clear();

                cache.evictAll();

                cache.mCacheFullyMatchesDisk = false;

            }

        }