diff --git a/src/com/android/server/telecom/CallAudioManager.java b/src/com/android/server/telecom/CallAudioManager.java
index 32a5120..4fa08fa 100644
--- a/src/com/android/server/telecom/CallAudioManager.java
+++ b/src/com/android/server/telecom/CallAudioManager.java
@@ -25,6 +25,7 @@
 import android.telecom.CallAudioState;
 
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.os.SomeArgs;
 import com.android.internal.util.IndentingPrintWriter;
 import com.android.internal.util.Preconditions;
 
@@ -63,44 +64,56 @@
 
         @Override
         public void handleMessage(Message msg) {
-            switch (msg.what) {
-                case MSG_AUDIO_MANAGER_INITIALIZE: {
-                    mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-                    break;
+            SomeArgs args = (SomeArgs) msg.obj;
+            int arg2 = 0;
+            try {
+                if (args != null) {
+                    Session subsession = (Session) args.arg1;
+                    Log.continueSession(subsession, "CAM.hM_" + msg.what);
+                    arg2 = (int) args.arg2;
                 }
-                case MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL: {
-                    mAudioManager.abandonAudioFocusForCall();
-                    break;
-                }
-                case MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL: {
-                    int stream = msg.arg1;
-                    mAudioManager.requestAudioFocusForCall(
-                            stream,
-                            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
-                    break;
-                }
-                case MSG_AUDIO_MANAGER_SET_MODE: {
-                    int newMode = msg.arg1;
-                    int oldMode = mAudioManager.getMode();
-                    Log.v(this, "Request to change audio mode from %s to %s", modeToString(oldMode),
-                            modeToString(newMode));
-
-                    if (oldMode != newMode) {
-                        if (oldMode == AudioManager.MODE_IN_CALL &&
-                                newMode == AudioManager.MODE_RINGTONE) {
-                            Log.i(this, "Transition from IN_CALL -> RINGTONE."
-                                    + "  Resetting to NORMAL first.");
-                            mAudioManager.setMode(AudioManager.MODE_NORMAL);
-                        }
-                        mAudioManager.setMode(newMode);
-                        synchronized (mLock) {
-                            mMostRecentlyUsedMode = newMode;
-                        }
+                switch (msg.what) {
+                    case MSG_AUDIO_MANAGER_INITIALIZE: {
+                        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+                        break;
                     }
-                    break;
+                    case MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL: {
+                        mAudioManager.abandonAudioFocusForCall();
+                        break;
+                    }
+                    case MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL: {
+                        int stream = arg2;
+                        mAudioManager.requestAudioFocusForCall(
+                                stream,
+                                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
+                        break;
+                    }
+                    case MSG_AUDIO_MANAGER_SET_MODE: {
+                        int newMode = arg2;
+                        int oldMode = mAudioManager.getMode();
+                        Log.v(this, "Request to change audio mode from %s to %s", modeToString(oldMode),
+                                modeToString(newMode));
+
+                        if (oldMode != newMode) {
+                            if (oldMode == AudioManager.MODE_IN_CALL &&
+                                    newMode == AudioManager.MODE_RINGTONE) {
+                                Log.i(this, "Transition from IN_CALL -> RINGTONE."
+                                        + "  Resetting to NORMAL first.");
+                                mAudioManager.setMode(AudioManager.MODE_NORMAL);
+                            }
+                            mAudioManager.setMode(newMode);
+                            synchronized (mLock) {
+                                mMostRecentlyUsedMode = newMode;
+                            }
+                        }
+                        break;
+                    }
+                    default:
+                        break;
                 }
-                default:
-                    break;
+            } finally {
+                Log.endSession();
+                args.recycle();
             }
         }
     };
@@ -127,13 +140,21 @@
             CallAudioRouteStateMachine callAudioRouteStateMachine) {
         mContext = context;
         mLock = lock;
-        mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_INITIALIZE, 0, 0).sendToTarget();
+        mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_INITIALIZE,
+                setArgs(0)).sendToTarget();
         mCallsManager = callsManager;
         mAudioFocusStreamType = STREAM_NONE;
 
         mCallAudioRouteStateMachine = callAudioRouteStateMachine;
     }
 
+    private SomeArgs setArgs(int arg) {
+        SomeArgs args = SomeArgs.obtain();
+        args.arg1 = Log.createSubsession();
+        args.arg2 = arg;
+        return args;
+    }
+
     @VisibleForTesting
     public CallAudioState getCallAudioState() {
         return mCallAudioRouteStateMachine.getCurrentCallAudioState();
@@ -147,7 +168,8 @@
         if (hasFocus() && getForegroundCall() == call) {
             if (!call.isIncoming()) {
                 // Unmute new outgoing call.
-                mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.MUTE_OFF);
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                        CallAudioRouteStateMachine.MUTE_OFF);
             }
         }
     }
@@ -157,7 +179,8 @@
         Log.v(this, "onCallRemoved");
         if (mCallsManager.getCalls().isEmpty()) {
             Log.v(this, "all calls removed, resetting system audio to default state");
-            mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.REINITIALIZE);
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                    CallAudioRouteStateMachine.REINITIALIZE);
         }
 
         // If we didn't already have focus, there's nothing to do.
@@ -177,8 +200,8 @@
         Log.v(this, "onIncomingCallAnswered");
 
         if (mCallsManager.getCalls().size() == 1) {
-            mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.SWITCH_FOCUS,
-                    CallAudioRouteStateMachine.HAS_FOCUS);
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                    CallAudioRouteStateMachine.SWITCH_FOCUS, CallAudioRouteStateMachine.HAS_FOCUS);
         }
 
         if (call.can(android.telecom.Call.Details.CAPABILITY_SPEED_UP_MT_AUDIO)) {
@@ -201,7 +224,8 @@
     }
 
     void toggleMute() {
-        mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.TOGGLE_MUTE);
+        mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                CallAudioRouteStateMachine.TOGGLE_MUTE);
     }
 
     void mute(boolean shouldMute) {
@@ -217,7 +241,7 @@
             Log.v(this, "ignoring mute for emergency call");
         }
 
-        mCallAudioRouteStateMachine.sendMessage(shouldMute
+        mCallAudioRouteStateMachine.sendMessageWithSessionInfo(shouldMute
                 ? CallAudioRouteStateMachine.MUTE_ON : CallAudioRouteStateMachine.MUTE_OFF);
     }
 
@@ -230,23 +254,23 @@
         Log.v(this, "setAudioRoute, route: %s", CallAudioState.audioRouteToString(route));
         switch (route) {
             case CallAudioState.ROUTE_BLUETOOTH:
-                mCallAudioRouteStateMachine.sendMessage(
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                         CallAudioRouteStateMachine.SWITCH_BLUETOOTH);
                 return;
             case CallAudioState.ROUTE_SPEAKER:
-                mCallAudioRouteStateMachine.sendMessage(
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                         CallAudioRouteStateMachine.SWITCH_SPEAKER);
                 return;
             case CallAudioState.ROUTE_WIRED_HEADSET:
-                mCallAudioRouteStateMachine.sendMessage(
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                         CallAudioRouteStateMachine.SWITCH_HEADSET);
                 return;
             case CallAudioState.ROUTE_EARPIECE:
-                mCallAudioRouteStateMachine.sendMessage(
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                         CallAudioRouteStateMachine.SWITCH_EARPIECE);
                 return;
             case CallAudioState.ROUTE_WIRED_OR_EARPIECE:
-                mCallAudioRouteStateMachine.sendMessage(
+                mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                         CallAudioRouteStateMachine.SWITCH_WIRED_OR_EARPIECE);
                 return;
             default:
@@ -355,15 +379,12 @@
         if (mAudioFocusStreamType != stream) {
             Log.i(this, "requestAudioFocusAndSetMode : requesting stream: %s -> %s",
                     streamTypeToString(mAudioFocusStreamType), streamTypeToString(stream));
-            mAudioManagerHandler.obtainMessage(
-                    MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL,
-                    stream,
-                    0)
-                    .sendToTarget();
+            mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL,
+                    setArgs(stream)).sendToTarget();
         }
         mAudioFocusStreamType = stream;
-        mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.SWITCH_FOCUS,
-                CallAudioRouteStateMachine.HAS_FOCUS);
+        mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                CallAudioRouteStateMachine.SWITCH_FOCUS, CallAudioRouteStateMachine.HAS_FOCUS);
 
         setMode(mode);
     }
@@ -372,13 +393,13 @@
         if (hasFocus()) {
             setMode(AudioManager.MODE_NORMAL);
             Log.v(this, "abandoning audio focus");
-            mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL, 0, 0)
-                    .sendToTarget();
+            mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL,
+                    setArgs(0)).sendToTarget();
             mAudioFocusStreamType = STREAM_NONE;
             mCallToSpeedUpMTAudio = null;
         }
-        mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.SWITCH_FOCUS,
-                CallAudioRouteStateMachine.NO_FOCUS);
+        mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                CallAudioRouteStateMachine.SWITCH_FOCUS, CallAudioRouteStateMachine.NO_FOCUS);
     }
 
     /**
@@ -388,7 +409,8 @@
      */
     private void setMode(int newMode) {
         Preconditions.checkState(hasFocus());
-        mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_SET_MODE, newMode, 0).sendToTarget();
+        mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_SET_MODE,
+                setArgs(newMode)).sendToTarget();
     }
 
     private void updateAudioForForegroundCall() {
diff --git a/src/com/android/server/telecom/CallAudioRoutePeripheralAdapter.java b/src/com/android/server/telecom/CallAudioRoutePeripheralAdapter.java
index 26a4cb8..45e5afa 100644
--- a/src/com/android/server/telecom/CallAudioRoutePeripheralAdapter.java
+++ b/src/com/android/server/telecom/CallAudioRoutePeripheralAdapter.java
@@ -41,9 +41,10 @@
     @Override
     public void onBluetoothStateChange(BluetoothManager bluetoothManager) {
         if (bluetoothManager.isBluetoothAvailable()) {
-            mCallAudioRouteStateMachine.sendMessage(CallAudioRouteStateMachine.CONNECT_BLUETOOTH);
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
+                    CallAudioRouteStateMachine.CONNECT_BLUETOOTH);
         } else {
-            mCallAudioRouteStateMachine.sendMessage(
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                     CallAudioRouteStateMachine.DISCONNECT_BLUETOOTH);
         }
     }
@@ -59,17 +60,17 @@
     @Override
     public void onWiredHeadsetPluggedInChanged(boolean oldIsPluggedIn, boolean newIsPluggedIn) {
         if (!oldIsPluggedIn && newIsPluggedIn) {
-            mCallAudioRouteStateMachine.sendMessage(
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                     CallAudioRouteStateMachine.CONNECT_WIRED_HEADSET);
         } else if (oldIsPluggedIn && !newIsPluggedIn){
-            mCallAudioRouteStateMachine.sendMessage(
+            mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                     CallAudioRouteStateMachine.DISCONNECT_WIRED_HEADSET);
         }
     }
 
     @Override
     public void onDockChanged(boolean isDocked) {
-        mCallAudioRouteStateMachine.sendMessage(
+        mCallAudioRouteStateMachine.sendMessageWithSessionInfo(
                 isDocked ? CallAudioRouteStateMachine.CONNECT_DOCK
                         : CallAudioRouteStateMachine.DISCONNECT_DOCK
         );
diff --git a/src/com/android/server/telecom/CallAudioRouteStateMachine.java b/src/com/android/server/telecom/CallAudioRouteStateMachine.java
index e6ef8f4..f74e499 100644
--- a/src/com/android/server/telecom/CallAudioRouteStateMachine.java
+++ b/src/com/android/server/telecom/CallAudioRouteStateMachine.java
@@ -122,6 +122,18 @@
 
         @Override
         public boolean processMessage(Message msg) {
+            if (msg.obj != null && msg.obj instanceof Session) {
+                Log.continueSession((Session) msg.obj, "CARSM.pM_" + msg.what);
+            }
+            boolean isHandled = processMessageInternal(msg);
+            if (isHandled) {
+                // If !isHandled, unhandledMessage will be called so Log.endSession there.
+                Log.endSession();
+            }
+            return isHandled;
+        }
+
+        public boolean processMessageInternal(Message msg) {
             Log.d(this, "Message received: %s", msg);
             switch (msg.what) {
                 case CONNECT_WIRED_HEADSET:
@@ -216,8 +228,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -275,8 +287,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -313,8 +325,8 @@
 
     abstract class EarpieceRoute extends AudioState {
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -376,8 +388,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -435,8 +447,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -473,8 +485,8 @@
 
     abstract class HeadsetRoute extends AudioState {
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -540,8 +552,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -599,8 +611,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -637,8 +649,8 @@
 
     abstract class BluetoothRoute extends AudioState {
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -701,8 +713,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch(msg.what) {
@@ -766,8 +778,8 @@
         }
 
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch(msg.what) {
@@ -808,8 +820,8 @@
 
     abstract class SpeakerRoute extends AudioState {
         @Override
-        public boolean processMessage(Message msg) {
-            if (super.processMessage(msg) == HANDLED) {
+        public boolean processMessageInternal(Message msg) {
+            if (super.processMessageInternal(msg) == HANDLED) {
                 return HANDLED;
             }
             switch (msg.what) {
@@ -943,6 +955,14 @@
         return mCurrentCallAudioState;
     }
 
+    public void sendMessageWithSessionInfo(int message, int arg) {
+        sendMessage(message, arg, 0, Log.createSubsession());
+    }
+
+    public void sendMessageWithSessionInfo(int message) {
+        sendMessage(message, 0, 0, Log.createSubsession());
+    }
+
     /**
      * This is for state-independent changes in audio route (i.e. muting)
      * @param msg that couldn't be handled.
@@ -978,6 +998,8 @@
                 Log.e(this, new IllegalStateException(),
                         "Unexpected message code");
         }
+
+        Log.endSession();
     }
 
     private void setSpeakerphoneOn(boolean on) {
@@ -1094,7 +1116,12 @@
         //    SWITCH_HEADSET at end of queue.
         // 6. State machine handler processes SWITCH_SPEAKER.
         // 7. State machine handler processes SWITCH_HEADSET.
-        sendMessageAtFrontOfQueue(messageCode);
+        Session subsession = Log.createSubsession();
+        if(subsession != null) {
+            sendMessageAtFrontOfQueue(messageCode, subsession);
+        } else {
+            sendMessageAtFrontOfQueue(messageCode);
+        }
     }
 
     private CallAudioState getInitialAudioState() {
diff --git a/src/com/android/server/telecom/TelecomServiceImpl.java b/src/com/android/server/telecom/TelecomServiceImpl.java
index 91056d2..cd30e52 100644
--- a/src/com/android/server/telecom/TelecomServiceImpl.java
+++ b/src/com/android/server/telecom/TelecomServiceImpl.java
@@ -863,11 +863,13 @@
                 final UserHandle userHandle = Binder.getCallingUserHandle();
                 long token = Binder.clearCallingIdentity();
                 try {
+                    Log.startSession("TSI.pC");
                     final Intent intent = new Intent(Intent.ACTION_CALL, handle);
                     intent.putExtras(extras);
                     new UserCallIntentProcessor(mContext, userHandle).processIntent(intent,
                             callingPackage, hasCallAppOp && hasCallPermission);
                 } finally {
+                    Log.endSession();
                     Binder.restoreCallingIdentity(token);
                 }
             }
diff --git a/src/com/android/server/telecom/components/PrimaryCallReceiver.java b/src/com/android/server/telecom/components/PrimaryCallReceiver.java
index 5198862..a05f04e 100644
--- a/src/com/android/server/telecom/components/PrimaryCallReceiver.java
+++ b/src/com/android/server/telecom/components/PrimaryCallReceiver.java
@@ -1,5 +1,6 @@
 package com.android.server.telecom.components;
 
+import com.android.server.telecom.Log;
 import com.android.server.telecom.TelecomSystem;
 
 import android.content.BroadcastReceiver;
@@ -16,9 +17,11 @@
 
     @Override
     public void onReceive(Context context, Intent intent) {
+        Log.startSession("PCR.oR");
         synchronized (getTelecomSystem().getLock()) {
             getTelecomSystem().getCallIntentProcessor().processIntent(intent);
         }
+        Log.endSession();
     }
 
     @Override
diff --git a/src/com/android/server/telecom/components/UserCallActivity.java b/src/com/android/server/telecom/components/UserCallActivity.java
index d88e09e..39cb4f9 100644
--- a/src/com/android/server/telecom/components/UserCallActivity.java
+++ b/src/com/android/server/telecom/components/UserCallActivity.java
@@ -52,18 +52,23 @@
     @Override
     protected void onCreate(Bundle bundle) {
         super.onCreate(bundle);
-        // TODO: Figure out if there is something to restore from bundle.
-        // See OutgoingCallBroadcaster in services/Telephony for more.
-        Intent intent = getIntent();
-        verifyCallAction(intent);
-        final UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
-        final UserHandle userHandle = new UserHandle(userManager.getUserHandle());
-        // Once control flow has passed to this activity, it is no longer guaranteed that we can
-        // accurately determine whether the calling package has the CALL_PHONE runtime permission.
-        // At this point in time we trust that the ActivityManager has already performed this
-        // validation before starting this activity.
-        new UserCallIntentProcessor(this, userHandle).processIntent(getIntent(),
-                getCallingPackage(), true /* hasCallAppOp*/);
+        Log.startSession("UCA.oC");
+        try {
+            // TODO: Figure out if there is something to restore from bundle.
+            // See OutgoingCallBroadcaster in services/Telephony for more.
+            Intent intent = getIntent();
+            verifyCallAction(intent);
+            final UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
+            final UserHandle userHandle = new UserHandle(userManager.getUserHandle());
+            // Once control flow has passed to this activity, it is no longer guaranteed that we can
+            // accurately determine whether the calling package has the CALL_PHONE runtime permission.
+            // At this point in time we trust that the ActivityManager has already performed this
+            // validation before starting this activity.
+            new UserCallIntentProcessor(this, userHandle).processIntent(getIntent(),
+                    getCallingPackage(), true /* hasCallAppOp*/);
+        } finally {
+            Log.endSession();
+        }
         finish();
     }
 
diff --git a/tests/src/com/android/server/telecom/tests/CallAudioRouteStateMachineTest.java b/tests/src/com/android/server/telecom/tests/CallAudioRouteStateMachineTest.java
index 496ad7d..0f55a45 100644
--- a/tests/src/com/android/server/telecom/tests/CallAudioRouteStateMachineTest.java
+++ b/tests/src/com/android/server/telecom/tests/CallAudioRouteStateMachineTest.java
@@ -175,16 +175,16 @@
                 CallAudioState.ROUTE_EARPIECE | CallAudioState.ROUTE_SPEAKER);
         stateMachine.initialize(initState);
 
-        stateMachine.sendMessage(CallAudioRouteStateMachine.SWITCH_FOCUS,
+        stateMachine.sendMessageWithSessionInfo(CallAudioRouteStateMachine.SWITCH_FOCUS,
                 CallAudioRouteStateMachine.HAS_FOCUS);
-        stateMachine.sendMessage(CallAudioRouteStateMachine.CONNECT_WIRED_HEADSET);
+        stateMachine.sendMessageWithSessionInfo(CallAudioRouteStateMachine.CONNECT_WIRED_HEADSET);
         CallAudioState expectedMiddleState = new CallAudioState(false,
                 CallAudioState.ROUTE_WIRED_HEADSET,
                 CallAudioState.ROUTE_WIRED_HEADSET | CallAudioState.ROUTE_SPEAKER);
         verifyNewSystemCallAudioState(initState, expectedMiddleState);
         resetMocks();
 
-        stateMachine.sendMessage(CallAudioRouteStateMachine.DISCONNECT_WIRED_HEADSET);
+        stateMachine.sendMessageWithSessionInfo(CallAudioRouteStateMachine.DISCONNECT_WIRED_HEADSET);
         verifyNewSystemCallAudioState(expectedMiddleState, initState);
     }
 
@@ -542,9 +542,9 @@
                 params.initialRoute, (params.availableRoutes | CallAudioState.ROUTE_SPEAKER));
         stateMachine.initialize(initState);
         // Make the state machine have focus so that we actually do something
-        stateMachine.sendMessage(CallAudioRouteStateMachine.SWITCH_FOCUS,
+        stateMachine.sendMessageWithSessionInfo(CallAudioRouteStateMachine.SWITCH_FOCUS,
                 CallAudioRouteStateMachine.HAS_FOCUS);
-        stateMachine.sendMessage(params.action);
+        stateMachine.sendMessageWithSessionInfo(params.action);
 
         // Verify interactions with the speakerphone and bluetooth systems
         switch(params.bluetoothInteraction) {
@@ -601,7 +601,7 @@
                 params.initialRoute, (params.availableRoutes | CallAudioState.ROUTE_SPEAKER));
         stateMachine.initialize(initState);
         // Omit the focus-getting statement
-        stateMachine.sendMessage(params.action);
+        stateMachine.sendMessageWithSessionInfo(params.action);
         try {
             Thread.sleep(100L);
         } catch (InterruptedException e) {