diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_call_merge_white_36.png b/assets/quantum/res/drawable-hdpi/quantum_ic_call_merge_white_36.png
deleted file mode 100644
index b7aba80..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_call_merge_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_dialpad_white_36.png b/assets/quantum/res/drawable-hdpi/quantum_ic_dialpad_white_36.png
deleted file mode 100644
index 82710e7..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_dialpad_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_group_white_36.png b/assets/quantum/res/drawable-hdpi/quantum_ic_group_white_36.png
deleted file mode 100644
index f98a074..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_group_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_pause_white_36.png b/assets/quantum/res/drawable-hdpi/quantum_ic_pause_white_36.png
deleted file mode 100644
index 1d02439..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_pause_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_videocam_white_36.png b/assets/quantum/res/drawable-hdpi/quantum_ic_videocam_white_36.png
deleted file mode 100644
index 49562a6..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_videocam_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_call_merge_white_36.png b/assets/quantum/res/drawable-mdpi/quantum_ic_call_merge_white_36.png
deleted file mode 100644
index a2eb54b..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_call_merge_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_dialpad_white_36.png b/assets/quantum/res/drawable-mdpi/quantum_ic_dialpad_white_36.png
deleted file mode 100644
index 9037f94..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_dialpad_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_group_white_36.png b/assets/quantum/res/drawable-mdpi/quantum_ic_group_white_36.png
deleted file mode 100644
index 25e4434..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_group_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_pause_white_36.png b/assets/quantum/res/drawable-mdpi/quantum_ic_pause_white_36.png
deleted file mode 100644
index 4d2ea05..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_pause_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_videocam_white_36.png b/assets/quantum/res/drawable-mdpi/quantum_ic_videocam_white_36.png
deleted file mode 100644
index d83e0d5..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_videocam_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_call_merge_white_36.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_call_merge_white_36.png
deleted file mode 100644
index 01daecf..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_call_merge_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_dialpad_white_36.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_dialpad_white_36.png
deleted file mode 100644
index 1750005..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_dialpad_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_group_white_36.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_group_white_36.png
deleted file mode 100644
index 7f0b7e9..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_group_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_pause_white_36.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_pause_white_36.png
deleted file mode 100644
index 7192ad4..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_pause_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_videocam_white_36.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_videocam_white_36.png
deleted file mode 100644
index 44c28e2..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_videocam_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_call_merge_white_36.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_call_merge_white_36.png
deleted file mode 100644
index cefef65..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_call_merge_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_dialpad_white_36.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_dialpad_white_36.png
deleted file mode 100644
index 54ebbaf..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_dialpad_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_group_white_36.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_group_white_36.png
deleted file mode 100644
index 952e15f..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_group_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_pause_white_36.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_pause_white_36.png
deleted file mode 100644
index a03bad2..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_pause_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_videocam_white_36.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_videocam_white_36.png
deleted file mode 100644
index 839af26..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_videocam_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_call_merge_white_36.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_call_merge_white_36.png
deleted file mode 100644
index 9419ffb..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_call_merge_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_dialpad_white_36.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_dialpad_white_36.png
deleted file mode 100644
index a53aeb1..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_dialpad_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_group_white_36.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_group_white_36.png
deleted file mode 100644
index dacf299..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_group_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_pause_white_36.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_pause_white_36.png
deleted file mode 100644
index 3ea7e03..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_pause_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_videocam_white_36.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_videocam_white_36.png
deleted file mode 100644
index eff5923..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_videocam_white_36.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable/quantum_ic_call_merge_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_call_merge_vd_theme_24.xml
new file mode 100644
index 0000000..660faf4
--- /dev/null
+++ b/assets/quantum/res/drawable/quantum_ic_call_merge_vd_theme_24.xml
@@ -0,0 +1,25 @@
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed 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
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24.0"
+    android:viewportHeight="24.0"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M17,20.41L18.41,19 15,15.59 13.59,17 17,20.41zM7.5,8H11v5.59L5.59,19 7,20.41l6,-6V8h3.5L12,3.5 7.5,8z"/>
+</vector>
diff --git a/java/com/android/incallui/incall/impl/ButtonController.java b/java/com/android/incallui/incall/impl/ButtonController.java
index 5e37a49..dd11fff 100644
--- a/java/com/android/incallui/incall/impl/ButtonController.java
+++ b/java/com/android/incallui/incall/impl/ButtonController.java
@@ -293,7 +293,7 @@
           R.string.incall_content_description_muted,
           R.string.incall_content_description_unmuted,
           R.string.incall_label_mute,
-          R.drawable.quantum_ic_mic_off_white_36);
+          R.drawable.quantum_ic_mic_off_vd_theme_24);
     }
 
     @Override
@@ -312,7 +312,7 @@
     private CheckableLabeledButton button;
 
     @StringRes private int label = R.string.incall_label_speaker;
-    @DrawableRes private int icon = R.drawable.quantum_ic_volume_up_white_36;
+    @DrawableRes private int icon = R.drawable.quantum_ic_volume_up_vd_theme_24;
     private boolean checkable;
     private CharSequence contentDescription;
     private CharSequence checkedContentDescription;
@@ -421,7 +421,7 @@
           0,
           0,
           R.string.incall_label_dialpad,
-          R.drawable.quantum_ic_dialpad_white_36);
+          R.drawable.quantum_ic_dialpad_vd_theme_24);
     }
 
     @Override
@@ -439,7 +439,7 @@
           R.string.incall_content_description_unhold,
           R.string.incall_content_description_hold,
           R.string.incall_label_hold,
-          R.drawable.quantum_ic_pause_white_36);
+          R.drawable.quantum_ic_pause_vd_theme_24);
     }
 
     @Override
@@ -474,7 +474,7 @@
           InCallButtonIds.BUTTON_SWAP,
           R.string.incall_content_description_swap_calls,
           R.string.incall_label_swap,
-          R.drawable.quantum_ic_swap_calls_white_36);
+          R.drawable.quantum_ic_swap_calls_vd_theme_24);
       Assert.isNotNull(delegate);
     }
 
@@ -492,7 +492,7 @@
           InCallButtonIds.BUTTON_MERGE,
           R.string.incall_content_description_merge_calls,
           R.string.incall_label_merge,
-          R.drawable.quantum_ic_call_merge_white_36);
+          R.drawable.quantum_ic_call_merge_vd_theme_24);
       Assert.isNotNull(delegate);
     }
 
@@ -510,7 +510,7 @@
           InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO,
           0,
           R.string.incall_label_videocall,
-          R.drawable.quantum_ic_videocam_white_36);
+          R.drawable.quantum_ic_videocam_vd_theme_24);
       Assert.isNotNull(delegate);
     }
 
@@ -530,7 +530,7 @@
           InCallButtonIds.BUTTON_MANAGE_VOICE_CONFERENCE,
           R.string.a11y_description_incall_label_manage_content,
           R.string.incall_label_manage,
-          R.drawable.quantum_ic_group_white_36);
+          R.drawable.quantum_ic_group_vd_theme_24);
       Assert.isNotNull(inCallScreenDelegate);
       this.inCallScreenDelegate = inCallScreenDelegate;
     }
@@ -551,7 +551,7 @@
           InCallButtonIds.BUTTON_SWITCH_TO_SECONDARY,
           R.string.incall_content_description_swap_calls,
           R.string.incall_label_swap,
-          R.drawable.quantum_ic_swap_calls_white_36);
+          R.drawable.quantum_ic_swap_calls_vd_theme_24);
       Assert.isNotNull(inCallScreenDelegate);
       this.inCallScreenDelegate = inCallScreenDelegate;
     }
diff --git a/java/com/android/incallui/incall/impl/CheckableLabeledButton.java b/java/com/android/incallui/incall/impl/CheckableLabeledButton.java
index ca018ac..03e6e37 100644
--- a/java/com/android/incallui/incall/impl/CheckableLabeledButton.java
+++ b/java/com/android/incallui/incall/impl/CheckableLabeledButton.java
@@ -34,7 +34,6 @@
 import android.view.SoundEffectConstants;
 import android.widget.Checkable;
 import android.widget.ImageView;
-import android.widget.ImageView.ScaleType;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
@@ -82,13 +81,15 @@
     setPadding(paddingSize, paddingSize, paddingSize, paddingSize);
 
     int iconSize = getResources().getDimensionPixelSize(R.dimen.incall_labeled_button_size);
+    int imageSize = getResources().getDimensionPixelSize(R.dimen.incall_labeled_button_icon_size);
+    int iconPadding = (iconSize - imageSize) / 2;
 
     iconView = new ImageView(context, null, android.R.style.Widget_Material_Button_Colored);
     LayoutParams iconParams = generateDefaultLayoutParams();
     iconParams.width = iconSize;
     iconParams.height = iconSize;
     iconView.setLayoutParams(iconParams);
-    iconView.setScaleType(ScaleType.CENTER_INSIDE);
+    iconView.setPadding(iconPadding, iconPadding, iconPadding, iconPadding);
     iconView.setImageDrawable(icon);
     iconView.setImageTintMode(Mode.SRC_IN);
     iconView.setImageTintList(getResources().getColorStateList(R.color.incall_button_icon, null));
diff --git a/java/com/android/incallui/incall/impl/res/values/dimens.xml b/java/com/android/incallui/incall/impl/res/values/dimens.xml
index 076a7d7..439dc1d 100644
--- a/java/com/android/incallui/incall/impl/res/values/dimens.xml
+++ b/java/com/android/incallui/incall/impl/res/values/dimens.xml
@@ -23,6 +23,7 @@
   <dimen name="incall_button_vertical_padding">8dp</dimen>
   <dimen name="incall_avatar_size">0dp</dimen>
   <dimen name="incall_labeled_button_size">48dp</dimen>
+  <dimen name="incall_labeled_button_icon_size">36dp</dimen>
   <dimen name="tools_button_height">76dp</dimen>
   <dimen name="incall_window_margin_horizontal">24dp</dimen>
 
