The Tor Browser: comparison mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/tsccm/AbstractConnPool.java

--1:000000000000
+:e3d21df0053e
+/*
+* ====================================================================
+*
+*  Licensed to the Apache Software Foundation (ASF) under one or more
+*  contributor license agreements.  See the NOTICE file distributed with
+*  this work for additional information regarding copyright ownership.
+*  The ASF licenses this file to You 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.
+* ====================================================================
+*
+* This software consists of voluntary contributions made by many
+* individuals on behalf of the Apache Software Foundation.  For more
+* information on the Apache Software Foundation, please see
+* <http://www.apache.org/>.
+*
+*/
+package ch.boye.httpclientandroidlib.impl.conn.tsccm;
+import java.io.IOException;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import ch.boye.httpclientandroidlib.annotation.GuardedBy;
+import ch.boye.httpclientandroidlib.androidextra.HttpClientAndroidLog;
+/* LogFactory removed by HttpClient for Android script. */
+import ch.boye.httpclientandroidlib.conn.ConnectionPoolTimeoutException;
+import ch.boye.httpclientandroidlib.conn.OperatedClientConnection;
+import ch.boye.httpclientandroidlib.conn.routing.HttpRoute;
+import ch.boye.httpclientandroidlib.impl.conn.IdleConnectionHandler;
+/**
+* An abstract connection pool.
+* It is used by the {@link ThreadSafeClientConnManager}.
+* The abstract pool includes a {@link #poolLock}, which is used to
+* synchronize access to the internal pool datastructures.
+* Don't use <code>synchronized</code> for that purpose!
+*
+* @since 4.0
+*/
+@Deprecated
+public abstract class AbstractConnPool implements RefQueueHandler {
+public HttpClientAndroidLog log;
+/**
+* The global lock for this pool.
+*/
+protected final Lock poolLock;
+/** References to issued connections */
+@GuardedBy("poolLock")
+protected Set<BasicPoolEntry> leasedConnections;
+/** The current total number of connections. */
+@GuardedBy("poolLock")
+protected int numConnections;
+/** Indicates whether this pool is shut down. */
+protected volatile boolean isShutDown;
+protected Set<BasicPoolEntryRef> issuedConnections;
+protected ReferenceQueue<Object> refQueue;
+protected IdleConnectionHandler idleConnHandler;
+/**
+* Creates a new connection pool.
+*/
+protected AbstractConnPool() {
+super();
+this.log = new HttpClientAndroidLog(getClass());
+this.leasedConnections = new HashSet<BasicPoolEntry>();
+this.idleConnHandler = new IdleConnectionHandler();
+this.poolLock = new ReentrantLock();
+}
+public void enableConnectionGC()
+throws IllegalStateException {
+}
+/**
+* Obtains a pool entry with a connection within the given timeout.
+*
+* @param route     the route for which to get the connection
+* @param timeout   the timeout, 0 or negative for no timeout
+* @param tunit     the unit for the <code>timeout</code>,
+*                  may be <code>null</code> only if there is no timeout
+*
+* @return  pool entry holding a connection for the route
+*
+* @throws ConnectionPoolTimeoutException
+*         if the timeout expired
+* @throws InterruptedException
+*         if the calling thread was interrupted
+*/
+public final
+BasicPoolEntry getEntry(
+HttpRoute route,
+Object state,
+long timeout,
+TimeUnit tunit)
+throws ConnectionPoolTimeoutException, InterruptedException {
+return requestPoolEntry(route, state).getPoolEntry(timeout, tunit);
+}
+/**
+* Returns a new {@link PoolEntryRequest}, from which a {@link BasicPoolEntry}
+* can be obtained, or the request can be aborted.
+*/
+public abstract PoolEntryRequest requestPoolEntry(HttpRoute route, Object state);
+/**
+* Returns an entry into the pool.
+* The connection of the entry is expected to be in a suitable state,
+* either open and re-usable, or closed. The pool will not make any
+* attempt to determine whether it can be re-used or not.
+*
+* @param entry     the entry for the connection to release
+* @param reusable  <code>true</code> if the entry is deemed
+*                  reusable, <code>false</code> otherwise.
+* @param validDuration The duration that the entry should remain free and reusable.
+* @param timeUnit The unit of time the duration is measured in.
+*/
+public abstract void freeEntry(BasicPoolEntry entry, boolean reusable, long validDuration, TimeUnit timeUnit)
+;
+public void handleReference(Reference<?> ref) {
+}
+protected abstract void handleLostEntry(HttpRoute route);
+/**
+* Closes idle connections.
+*
+* @param idletime  the time the connections should have been idle
+*                  in order to be closed now
+* @param tunit     the unit for the <code>idletime</code>
+*/
+public void closeIdleConnections(long idletime, TimeUnit tunit) {
+// idletime can be 0 or negative, no problem there
+if (tunit == null) {
+throw new IllegalArgumentException("Time unit must not be null.");
+}
+poolLock.lock();
+try {
+idleConnHandler.closeIdleConnections(tunit.toMillis(idletime));
+} finally {
+poolLock.unlock();
+}
+}
+public void closeExpiredConnections() {
+poolLock.lock();
+try {
+idleConnHandler.closeExpiredConnections();
+} finally {
+poolLock.unlock();
+}
+}
+/**
+* Deletes all entries for closed connections.
+*/
+public abstract void deleteClosedConnections();
+/**
+* Shuts down this pool and all associated resources.
+* Overriding methods MUST call the implementation here!
+*/
+public void shutdown() {
+poolLock.lock();
+try {
+if (isShutDown)
+return;
+// close all connections that are issued to an application
+Iterator<BasicPoolEntry> iter = leasedConnections.iterator();
+while (iter.hasNext()) {
+BasicPoolEntry entry = iter.next();
+iter.remove();
+closeConnection(entry.getConnection());
+}
+idleConnHandler.removeAll();
+isShutDown = true;
+} finally {
+poolLock.unlock();
+}
+}
+/**
+* Closes a connection from this pool.
+*
+* @param conn      the connection to close, or <code>null</code>
+*/
+protected void closeConnection(final OperatedClientConnection conn) {
+if (conn != null) {
+try {
+conn.close();
+} catch (IOException ex) {
+log.debug("I/O error closing connection", ex);
+}
+}
+}
+} // class AbstractConnPool

The Tor Browser / file comparison

comparison: mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/tsccm/AbstractConnPool.java

mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/tsccm/AbstractConnPool.java