Merge "Remove superfluous code after removal of Android HTTP stack"

package android.webkit;

import android.content.Context;

import android.net.http.AndroidHttpClient;

import android.net.http.Headers;

import android.os.FileUtils;

import android.util.Log;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.List;

import java.util.Map;

import com.android.org.bouncycastle.crypto.Digest;

import com.android.org.bouncycastle.crypto.digests.SHA1Digest;

/**

 * Manages the HTTP cache used by an application's {@link WebView} instances.

 * @deprecated Access to the HTTP cache will be removed in a future release.

import android.net.ParseException;

import android.net.WebAddress;

import android.net.http.AndroidHttpClient;

import android.os.AsyncTask;

import android.util.Log;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Comparator;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.SortedSet;

import java.util.TreeSet;

/**

 * Manages the cookies used by an application's {@link WebView} instances.

 * Cookies are manipulated according to RFC2109.

    private static final String LOGTAG = "webkit";

    private static final String DOMAIN = "domain";

    private static final String PATH = "path";

    private static final String EXPIRES = "expires";

    private static final String SECURE = "secure";

    private static final String MAX_AGE = "max-age";

    private static final String HTTP_ONLY = "httponly";

    private static final String HTTPS = "https";

    private static final char PERIOD = '.';

    private static final char COMMA = ',';

    private static final char SEMICOLON = ';';

    private static final char EQUAL = '=';

    private static final char PATH_DELIM = '/';

    private static final char QUESTION_MARK = '?';

    private static final char WHITE_SPACE = ' ';

    private static final char QUOTATION = '\"';

    private static final int SECURE_LENGTH = SECURE.length();

    private static final int HTTP_ONLY_LENGTH = HTTP_ONLY.length();

    // RFC2109 defines 4k as maximum size of a cookie

    private static final int MAX_COOKIE_LENGTH = 4 * 1024;

    // RFC2109 defines 20 as max cookie count per domain. As we track with base

    // domain, we allow 50 per base domain

    private static final int MAX_COOKIE_COUNT_PER_BASE_DOMAIN = 50;

    // RFC2109 defines 300 as max count of domains. As we track with base

    // domain, we set 200 as max base domain count

    private static final int MAX_DOMAIN_COUNT = 200;

    // max cookie count to limit RAM cookie takes less than 100k, it is based on

    // average cookie entry size is less than 100 bytes

    private static final int MAX_RAM_COOKIES_COUNT = 1000;

    //  max domain count to limit RAM cookie takes less than 100k,

    private static final int MAX_RAM_DOMAIN_COUNT = 15;

    private int mPendingCookieOperations = 0;

    /**

     * This contains a list of 2nd-level domains that aren't allowed to have

     * wildcards when combined with country-codes. For example: [.co.uk].

     */

    private final static String[] BAD_COUNTRY_2LDS =

          { "ac", "co", "com", "ed", "edu", "go", "gouv", "gov", "info",

            "lg", "ne", "net", "or", "org" };

    static {

        Arrays.sort(BAD_COUNTRY_2LDS);

    }

    /**

     * Package level class to be accessed by cookie sync manager

     */

    static class Cookie {

        static final byte MODE_NEW = 0;

        static final byte MODE_NORMAL = 1;

        static final byte MODE_DELETED = 2;

        static final byte MODE_REPLACED = 3;

        String domain;

        String path;

        String name;

        String value;

        long expires;

        long lastAcessTime;

        long lastUpdateTime;

        boolean secure;

        byte mode;

        Cookie() {

        }

        Cookie(String defaultDomain, String defaultPath) {

            domain = defaultDomain;

            path = defaultPath;

            expires = -1;

        }

        boolean exactMatch(Cookie in) {

            // An exact match means that domain, path, and name are equal. If

            // both values are null, the cookies match. If both values are

            // non-null, the cookies match. If one value is null and the other

            // is non-null, the cookies do not match (i.e. "foo=;" and "foo;")

            boolean valuesMatch = !((value == null) ^ (in.value == null));

            return domain.equals(in.domain) && path.equals(in.path) &&

                    name.equals(in.name) && valuesMatch;

        }

        boolean domainMatch(String urlHost) {

            if (domain.startsWith(".")) {

                if (urlHost.endsWith(domain.substring(1))) {

                    int len = domain.length();

                    int urlLen = urlHost.length();

                    if (urlLen > len - 1) {

                        // make sure bar.com doesn't match .ar.com

                        return urlHost.charAt(urlLen - len) == PERIOD;

                    }

                    return true;

                }

                return false;

            } else {

                // exact match if domain is not leading w/ dot

                return urlHost.equals(domain);

            }

        }

        boolean pathMatch(String urlPath) {

            if (urlPath.startsWith(path)) {

                int len = path.length();

                if (len == 0) {

                    Log.w(LOGTAG, "Empty cookie path");

                    return false;

                }

                int urlLen = urlPath.length();

                if (path.charAt(len-1) != PATH_DELIM && urlLen > len) {

                    // make sure /wee doesn't match /we

                    return urlPath.charAt(len) == PATH_DELIM;

                }

                return true;

            }

            return false;

        }

        public String toString() {

            return "domain: " + domain + "; path: " + path + "; name: " + name

                    + "; value: " + value;

        }

    }

    private static final CookieComparator COMPARATOR = new CookieComparator();

    private static final class CookieComparator implements Comparator<Cookie> {

        public int compare(Cookie cookie1, Cookie cookie2) {

            // According to RFC 2109, multiple cookies are ordered in a way such

            // that those with more specific Path attributes precede those with

            // less specific. Ordering with respect to other attributes (e.g.,

            // Domain) is unspecified.

            // As Set is not modified if the two objects are same, we do want to

            // assign different value for each cookie.

            int diff = cookie2.path.length() - cookie1.path.length();

            if (diff != 0) return diff;

            diff = cookie2.domain.length() - cookie1.domain.length();

            if (diff != 0) return diff;

            // If cookie2 has a null value, it should come later in

            // the list.

            if (cookie2.value == null) {

                // If both cookies have null values, fall back to using the name

                // difference.

                if (cookie1.value != null) {

                    return -1;

                }

            } else if (cookie1.value == null) {

                // Now we know that cookie2 does not have a null value, if

                // cookie1 has a null value, place it later in the list.

                return 1;

            }

            // Fallback to comparing the name to ensure consistent order.

            return cookie1.name.compareTo(cookie2.name);

        }

    }

    private CookieManager() {

    }

import android.content.Context;

import android.util.Log;

import android.webkit.CookieManager.Cookie;

import java.util.ArrayList;

import java.util.Iterator;

/**

 * The CookieSyncManager is used to synchronize the browser cookie store

    private static CookieSyncManager sRef;

    // time when last update happened

    private long mLastUpdate;

    private CookieSyncManager(Context context) {

        super(context, "CookieSyncManager");

    }