import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
/**
 * Create a new ProxyToServerConnection.
 * 
 * @param proxyServer
 * @param clientConnection
 * @param serverHostAndPort
 * @param initialHttpRequest
 * @return
 * @throws UnknownHostException
 */
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        HttpRequest initialHttpRequest)
        throws UnknownHostException {
    Queue<ChainedProxy> chainedProxies = new ConcurrentLinkedQueue<ChainedProxy>();
    ChainedProxyManager chainedProxyManager = proxyServer
            .getChainProxyManager();
    if (chainedProxyManager != null) {
        chainedProxyManager.lookupChainedProxies(initialHttpRequest,
                chainedProxies);
    }
    return new ProxyToServerConnection(proxyServer, clientConnection,
            serverHostAndPort, chainedProxies.poll(), chainedProxies);
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
private DefaultHttpProxyServer(String name,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filterSource,
        boolean useDnsSec,
        boolean transparent,
        int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this(new ServerGroup(name), transportProtocol, address,
            sslEngineSource, authenticateSslClients, proxyAuthenticator,
            chainProxyManager,
            mitmManager, filterSource, useDnsSec, transparent,
            idleConnectionTimeout, activityTrackers);
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
/**
 * Allows access to the LittleProxy {@link ChainedProxyManager} for fine-grained control of the chained proxies. To enable a single
 * chained proxy, {@link BrowserMobProxy#setChainedProxy(InetSocketAddress)} is generally more convenient.
 *
 * @param chainedProxyManager chained proxy manager to enable
 */
public void setChainedProxyManager(ChainedProxyManager chainedProxyManager) {
    if (isStarted()) {
        throw new IllegalStateException("Cannot configure chained proxy manager after proxy has started.");
    }

    this.chainedProxyManager = chainedProxyManager;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
/**
 * Create a new ProxyToServerConnection.
 * 
 * @param proxyServer
 * @param clientConnection
 * @param serverHostAndPort
 * @param initialFilters
 * @param initialHttpRequest
 * @return
 * @throws UnknownHostException
 */
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        HttpFilters initialFilters,
        HttpRequest initialHttpRequest,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    Queue<ChainedProxy> chainedProxies = new ConcurrentLinkedQueue<ChainedProxy>();
    ChainedProxyManager chainedProxyManager = proxyServer
            .getChainProxyManager();
    if (chainedProxyManager != null) {
        chainedProxyManager.lookupChainedProxies(initialHttpRequest,
                chainedProxies);
        if (chainedProxies.size() == 0) {
            // ChainedProxyManager returned no proxies, can't connect
            return null;
        }
    }
    return new ProxyToServerConnection(proxyServer,
            clientConnection,
            serverHostAndPort,
            chainedProxies.poll(),
            chainedProxies,
            initialFilters,
            globalTrafficShapingHandler);
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        ServerGroup serverGroup,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond,
        long  writeThrottleBytesPerSecond,
        InetSocketAddress localAddress,
        String proxyAlias) {
    this.serverGroup = serverGroup;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.mitmManager = mitmManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
    this.localAddress = localAddress;
    this.proxyAlias = proxyAlias;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond, long  writeThrottleBytesPerSecond) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withChainProxyManager(
        ChainedProxyManager chainProxyManager) {
    this.chainProxyManager = chainProxyManager;
    if (this.mitmManager != null) {
        LOG.warn("Enabled proxy chaining with man in the middle.  These are mutually exclusive - man in the middle will be disabled.");
        this.mitmManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
private void initProxyServer() throws Exception
{
   org.littleshoot.proxy.ProxyAuthenticator proxyAuthenticator = new org.littleshoot.proxy.ProxyAuthenticator()
   {
      @Override
      public boolean authenticate(String user, String pwd)
      {
         return (PROXY_USER.equals(user) && PROXY_PWD.equals(pwd));
      }
   };
   InetSocketAddress address = new InetSocketAddress(getServerHost(), ++proxyPort);
   ChainedProxyManager chainProxyManager = new ChainedProxyManager()
   {
      @Override
      public void lookupChainedProxies(HttpRequest httpRequest, Queue<ChainedProxy> chainedProxies)
      {
         chainedProxies.add(new ChainedProxyAdapter()
         {
            @Override
            public InetSocketAddress getChainedProxyAddress()
            {
               return new InetSocketAddress(getServerHost(), getServerPort());
            }

         });
      }
   };
   proxyServer = org.littleshoot.proxy.impl.DefaultHttpProxyServer
                         .bootstrap()
                         .withChainProxyManager(chainProxyManager)
                         .withAddress(address)
                         .withProxyAuthenticator(proxyAuthenticator)
                         .start();
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
protected ChainedProxyManager chainedProxyManager() {
    return new ChainedProxyManager() {
        @Override
        public void lookupChainedProxies(HttpRequest httpRequest,
                Queue<ChainedProxy> chainedProxies) {
            chainedProxies.add(newChainedProxy());
        }
    };
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource, boolean useDnsSec,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.address = address;
    this.port = address.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.useDnsSec = useDnsSec;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withChainProxyManager(
        ChainedProxyManager chainProxyManager) {
    this.chainProxyManager = chainProxyManager;
    if (this.mitmManager != null) {
        Log.w(TAG, "Enabled proxy chaining with man in the middle.  These are mutually exclusive - man in the middle will be disabled.");
        this.mitmManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
protected ChainedProxyManager getChainProxyManager() {
    return chainProxyManager;
}
 

import org.littleshoot.proxy.ChainedProxyManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withChainProxyManager(
        ChainedProxyManager chainProxyManager) {
    this.chainProxyManager = chainProxyManager;
    return this;
}