Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove superfluous code after removal of Android HTTP stack

Browse Source 
See b/5495616.

Bug: 6228353
Change-Id: I16cfd7b37973919d5bf14d2d80954caede264961
This commit is contained in:
Steve Block
2012-03-26 18:40:05 +01:00
parent a026b48972
commit f2bfe2bc05
3 changed files with 1 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
core/java/android/webkit/CacheManager.java
View File

@@ -17,25 +17,18 @@
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.

200
core/java/android/webkit/CookieManager.java
View File

@@ -18,21 +18,10 @@ package android.webkit;
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.
@@ -43,197 +32,8 @@ public final class CookieManager {
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() {
}

6
core/java/android/webkit/CookieSyncManager.java
View File

@@ -18,10 +18,7 @@ package android.webkit;
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
@@ -62,9 +59,6 @@ public final class CookieSyncManager extends WebSyncManager {
private static CookieSyncManager sRef;
// time when last update happened
private long mLastUpdate;
private CookieSyncManager(Context context) {
super(context, "CookieSyncManager");
}