diff --git a/res/values/styles.xml b/res/values/styles.xml
index 880460b..4edacdf 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -376,9 +376,10 @@
         <item name="android:fontFamily">sans-serif</item>
     </style>
 
-    <style name="ContactsAlertDialogTheme" parent="Theme.AppCompat.Light.Dialog.MinWidth">
+    <!-- Inherit from Theme.Material.Light.Dialog instead of Theme.Material.Light.Dialog.Alert
+        since the Alert dialog is private. They are identical anyway. -->
+    <style name="ContactsAlertDialogTheme" parent="@android:style/Theme.Material.Light.Dialog">
         <item name="android:colorAccent">@color/primary_color</item>
-        <item name="colorAccent">@color/primary_color</item>
     </style>
 
     <style name="EditKindIconStyle">
diff --git a/src/com/android/contacts/group/GroupNameEditDialogFragment.java b/src/com/android/contacts/group/GroupNameEditDialogFragment.java
index 8fcd63d..bc877a2 100644
--- a/src/com/android/contacts/group/GroupNameEditDialogFragment.java
+++ b/src/com/android/contacts/group/GroupNameEditDialogFragment.java
@@ -15,6 +15,7 @@
  */
 package com.android.contacts.group;
 
+import android.app.AlertDialog;
 import android.app.Dialog;
 import android.app.DialogFragment;
 import android.app.FragmentManager;
@@ -22,10 +23,10 @@
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnClickListener;
 import android.os.Bundle;
-import android.support.v7.app.AlertDialog;
 import android.text.Editable;
 import android.text.TextUtils;
 import android.text.TextWatcher;
+import android.view.ContextThemeWrapper;
 import android.view.View;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.Button;
@@ -90,7 +91,9 @@
     @Override
     public Dialog onCreateDialog(Bundle savedInstanceState) {
         // Build a dialog with two buttons and a view of a single EditText input field
-        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
+        final ContextThemeWrapper context = new ContextThemeWrapper(getActivity(),
+                android.R.style.Theme_Holo_Light_Dialog_MinWidth);
+        final AlertDialog.Builder builder = new AlertDialog.Builder(context)
                 .setTitle(mIsInsert
                         ? R.string.group_name_dialog_insert_title
                         : R.string.group_name_dialog_update_title)
