Separate the timeout behavior from PacketRetransmittingState class.

The purpose is to make subclass that only requires timeout method
could extend from TimeoutState instead of PacketRetransmittingState,
avoiding the anti-pattern of using inheritance for code reuse only.

After refactoring, class inheritance relationship looks like:

LoggingState <-- TimeoutState <-- PacketRetransmittingState <-- DhcpInitState

Bug: 140223017
Test: atest FrameworksNetTests NetworkStackTests
Test: atest NetworkStackIntegrationTests

Change-Id: I1fed3ff3ef8b0bdf3645188949e38c3a332f9d6e

1 files changed, 44 insertions, 19 deletions

diff --git a/src/android/net/dhcp/DhcpClient.java b/src/android/net/dhcp/DhcpClient.java
index e88c7cc..2a0a1d2 100644
--- a/src/android/net/dhcp/DhcpClient.java
+++ b/src/android/net/dhcp/DhcpClient.java
@@ -829,6 +829,42 @@ public class DhcpClient extends StateMachine {
                 (leaseTimeMillis > 0) ? SystemClock.elapsedRealtime() + leaseTimeMillis : 0;
     }
 
+    abstract class TimeoutState extends LoggingState {
+        protected int mTimeout = 0;
+
+        @Override
+        public void enter() {
+            super.enter();
+            maybeInitTimeout();
+        }
+
+        @Override
+        public boolean processMessage(Message message) {
+            super.processMessage(message);
+            switch (message.what) {
+                case CMD_TIMEOUT:
+                    timeout();
+                    return HANDLED;
+                default:
+                    return NOT_HANDLED;
+            }
+        }
+
+        @Override
+        public void exit() {
+            super.exit();
+            mTimeoutAlarm.cancel();
+        }
+
+        protected abstract void timeout();
+        private void maybeInitTimeout() {
+            if (mTimeout > 0) {
+                long alarmTime = SystemClock.elapsedRealtime() + mTimeout;
+                mTimeoutAlarm.schedule(alarmTime);
+            }
+        }
+    }
+
     /**
      * Retransmits packets using jittered exponential backoff with an optional timeout. Packet
      * transmission is triggered by CMD_KICK, which is sent by an AlarmManager alarm. If a subclass
@@ -840,22 +876,22 @@ public class DhcpClient extends StateMachine {
      * packet needs to be transmitted, and receivePacket, which is triggered by CMD_RECEIVED_PACKET
      * sent by the receive thread. They may also set mTimeout and implement timeout.
      */
-    abstract class PacketRetransmittingState extends LoggingState {
-
+    abstract class PacketRetransmittingState extends TimeoutState {
         private int mTimer;
-        protected int mTimeout = 0;
 
         @Override
         public void enter() {
             super.enter();
             initTimer();
-            maybeInitTimeout();
             sendMessage(CMD_KICK);
         }
 
         @Override
         public boolean processMessage(Message message) {
-            super.processMessage(message);
+            if (super.processMessage(message) == HANDLED) {
+                return HANDLED;
+            }
+
             switch (message.what) {
                 case CMD_KICK:
                     sendPacket();
@@ -864,9 +900,6 @@ public class DhcpClient extends StateMachine {
                 case CMD_RECEIVED_PACKET:
                     receivePacket((DhcpPacket) message.obj);
                     return HANDLED;
-                case CMD_TIMEOUT:
-                    timeout();
-                    return HANDLED;
                 default:
                     return NOT_HANDLED;
             }
@@ -876,11 +909,10 @@ public class DhcpClient extends StateMachine {
         public void exit() {
             super.exit();
             mKickAlarm.cancel();
-            mTimeoutAlarm.cancel();
         }
 
-        abstract protected boolean sendPacket();
-        abstract protected void receivePacket(DhcpPacket packet);
+        protected abstract boolean sendPacket();
+        protected abstract void receivePacket(DhcpPacket packet);
         protected void timeout() {}
 
         protected void initTimer() {
@@ -903,13 +935,6 @@ public class DhcpClient extends StateMachine {
                 mTimer = MAX_TIMEOUT_MS;
             }
         }
-
-        protected void maybeInitTimeout() {
-            if (mTimeout > 0) {
-                long alarmTime = SystemClock.elapsedRealtime() + mTimeout;
-                mTimeoutAlarm.schedule(alarmTime);
-            }
-        }
     }
 
     class ObtainingConfigurationState extends LoggingState {
@@ -1167,7 +1192,7 @@ public class DhcpClient extends StateMachine {
             startNewTransaction();
         }
 
-        abstract protected Inet4Address packetDestination();
+        protected abstract Inet4Address packetDestination();
 
         protected boolean sendPacket() {
             return sendRequestPacket(