more final and cleanups

router/java/src/net/i2p/router/transport/udp/IntroductionManager.java

@@ -21,10 +21,10 @@ import net.i2p.util.Log;
  *
  */
 class IntroductionManager {
-    private RouterContext _context;
+    private final RouterContext _context;
-    private Log _log;
+    private final Log _log;
-    private UDPTransport _transport;
+    private final UDPTransport _transport;
-    private PacketBuilder _builder;
+    private final PacketBuilder _builder;
     /** map of relay tag to PeerState that should receive the introduction */
     private final Map<Long, PeerState> _outbound;
     /** list of peers (PeerState) who have given us introduction tags */

router/java/src/net/i2p/router/transport/udp/MessageReceiver.java

@@ -20,9 +20,9 @@ import net.i2p.util.Log;
  * {@link net.i2p.router.InNetMessagePool} by way of the {@link UDPTransport}.
  */
 class MessageReceiver {
-    private RouterContext _context;
+    private final RouterContext _context;
-    private Log _log;
+    private final Log _log;
-    private UDPTransport _transport;
+    private final UDPTransport _transport;
     /** list of messages (InboundMessageState) fully received but not interpreted yet */
     private final BlockingQueue<InboundMessageState> _completeMessages;
     private boolean _alive;

router/java/src/net/i2p/router/transport/udp/OutboundEstablishState.java

@@ -50,7 +50,7 @@ class OutboundEstablishState {
     private long _nextSend;
     private RemoteHostId _remoteHostId;
     private final RouterIdentity _remotePeer;
-    private SessionKey _introKey;
+    private final SessionKey _introKey;
     private final Queue<OutNetMessage> _queuedMessages;
     private int _currentState;
     private long _introductionNonce;

router/java/src/net/i2p/router/transport/udp/PacketBuilder.java

@@ -95,9 +95,9 @@ around briefly, to address packet loss and reordering.</p>
  *
  */
 class PacketBuilder {
-    private I2PAppContext _context;
+    private final I2PAppContext _context;
-    private Log _log;
+    private final Log _log;
-    private UDPTransport _transport;
+    private final UDPTransport _transport;
     
     private static final ByteCache _ivCache = ByteCache.getInstance(64, UDPPacket.IV_SIZE);
     private static final ByteCache _hmacCache = ByteCache.getInstance(64, Hash.HASH_LENGTH);

router/java/src/net/i2p/router/transport/udp/PeerTestManager.java

@@ -91,17 +91,17 @@ with either Bob or Charlie, but it is not required.</p>
 
  */
 class PeerTestManager {
-    private RouterContext _context;
+    private final RouterContext _context;
-    private Log _log;
+    private final Log _log;
-    private UDPTransport _transport;
+    private final UDPTransport _transport;
-    private PacketBuilder _packetBuilder;
+    private final PacketBuilder _packetBuilder;
     /** map of Long(nonce) to PeerTestState for tests currently in progress (as Bob/Charlie) */
     private final Map<Long, PeerTestState> _activeTests;
     /** current test we are running (as Alice), or null */
     private PeerTestState _currentTest;
     private boolean _currentTestComplete;
     /** as Alice */
-    private Queue<Long> _recentTests;
+    private final Queue<Long> _recentTests;
     
     /** longest we will keep track of a Charlie nonce for */
     private static final int MAX_CHARLIE_LIFETIME = 10*1000;

router/java/src/net/i2p/router/transport/udp/UDPPacket.java

@@ -19,13 +19,13 @@ import net.i2p.util.Log;
 class UDPPacket {
     private I2PAppContext _context;
     private static Log _log;
-    private volatile DatagramPacket _packet;
+    private final DatagramPacket _packet;
     private volatile short _priority;
     private volatile long _initializeTime;
     private volatile long _expiration;
-    private byte[] _data;
+    private final byte[] _data;
-    private byte[] _validateBuf;
+    private final byte[] _validateBuf;
-    private byte[] _ivBuf;
+    private final byte[] _ivBuf;
     private volatile int _markedType;
     private volatile RemoteHostId _remoteHost;
     private volatile boolean _released;
@@ -81,22 +81,22 @@ class UDPPacket {
     
     private static final int MAX_VALIDATE_SIZE = MAX_PACKET_SIZE;
 
-    private UDPPacket(I2PAppContext ctx, boolean inbound) {
+    private UDPPacket(I2PAppContext ctx) {
         ctx.statManager().createRateStat("udp.fetchRemoteSlow", "How long it takes to grab the remote ip info", "udp", UDPTransport.RATES);
         // the data buffer is clobbered on init(..), but we need it to bootstrap
         _data = new byte[MAX_PACKET_SIZE];
         _packet = new DatagramPacket(_data, MAX_PACKET_SIZE);
         _validateBuf = new byte[MAX_VALIDATE_SIZE];
         _ivBuf = new byte[IV_SIZE];
-        init(ctx, inbound);
+        init(ctx);
     }
-    // FIXME optimization, remove the inbound parameter, as it is unused. FIXME
+
-    private void init(I2PAppContext ctx, boolean inbound) {
+    private void init(I2PAppContext ctx) {
         _context = ctx;
         //_dataBuf = _dataCache.acquire();
         Arrays.fill(_data, (byte)0);
         //_packet = new DatagramPacket(_data, MAX_PACKET_SIZE);
-        _packet.setData(_data);
+        //_packet.setData(_data);
         // _isInbound = inbound;
         _initializeTime = _context.clock().now();
         _markedType = -1;
@@ -262,15 +262,18 @@ class UDPPacket {
         return buf.toString();
     }
     
+    /**
+     *  @param inbound unused
+     */
     public static UDPPacket acquire(I2PAppContext ctx, boolean inbound) {
         UDPPacket rv = null;
         if (CACHE) {
             rv = _packetCache.poll();
             if (rv != null)
-                rv.init(ctx, inbound);
+                rv.init(ctx);
         }
         if (rv == null)
-            rv = new UDPPacket(ctx, inbound);
+            rv = new UDPPacket(ctx);
         //if (rv._acquiredBy != null) {
         //    _log.log(Log.CRIT, "Already acquired!  current stack trace is:", new Exception());
         //    _log.log(Log.CRIT, "Earlier acquired:", rv._acquiredBy);

router/java/src/net/i2p/router/transport/udp/UDPPacketReader.java

@@ -16,19 +16,19 @@ import net.i2p.util.Log;
  *
  */
 class UDPPacketReader {
-    private I2PAppContext _context;
+    private final I2PAppContext _context;
-    private Log _log;
+    private final Log _log;
     private byte _message[];
     private int _payloadBeginOffset;
     private int _payloadLength;
-    private SessionRequestReader _sessionRequestReader;
+    private final SessionRequestReader _sessionRequestReader;
-    private SessionCreatedReader _sessionCreatedReader;
+    private final SessionCreatedReader _sessionCreatedReader;
-    private SessionConfirmedReader _sessionConfirmedReader;
+    private final SessionConfirmedReader _sessionConfirmedReader;
-    private DataReader _dataReader;
+    private final DataReader _dataReader;
-    private PeerTestReader _peerTestReader;
+    private final PeerTestReader _peerTestReader;
-    private RelayRequestReader _relayRequestReader;
+    private final RelayRequestReader _relayRequestReader;
-    private RelayIntroReader _relayIntroReader;
+    private final RelayIntroReader _relayIntroReader;
-    private RelayResponseReader _relayResponseReader;
+    private final RelayResponseReader _relayResponseReader;
     
     private static final int KEYING_MATERIAL_LENGTH = 64;