diff --git a/src/com/android/contacts/group/GroupMembersFragment.java b/src/com/android/contacts/group/GroupMembersFragment.java
index be3b127..44bda74 100644
--- a/src/com/android/contacts/group/GroupMembersFragment.java
+++ b/src/com/android/contacts/group/GroupMembersFragment.java
@@ -50,7 +50,6 @@
 import com.android.contacts.R;
 import com.android.contacts.activities.ActionBarAdapter;
 import com.android.contacts.common.ContactsUtils;
-import com.android.contacts.common.Experiments;
 import com.android.contacts.common.list.ContactsSectionIndexer;
 import com.android.contacts.common.list.MultiSelectEntryContactListAdapter.DeleteContactListener;
 import com.android.contacts.common.logging.ListEvent;
@@ -65,7 +64,6 @@
 import com.android.contacts.list.MultiSelectContactsListFragment;
 import com.android.contacts.list.UiIntentActions;
 import com.android.contactsbind.FeedbackHelper;
-import com.android.contactsbind.experiments.Flags;
 import com.google.common.primitives.Longs;
 
 import java.util.ArrayList;
@@ -91,7 +89,6 @@
     private static final int LOADER_GROUP_METADATA = 0;
     private static final int MSG_FAIL_TO_LOAD = 1;
     private static final int RESULT_GROUP_ADD_MEMBER = 100;
-    private static final int RESULT_SEND_TO_SELECTION = 200;
 
     /** Filters out duplicate contacts. */
     private class FilterCursorWrapper extends CursorWrapper {
@@ -294,7 +291,7 @@
     /**
      * Helper class for cp2 query used to look up all contact's emails and phone numbers.
      */
-    private static abstract class Query {
+    public static abstract class Query {
         public static final String EMAIL_SELECTION =
                 ContactsContract.Data.MIMETYPE + "='"
                         + ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE + "'";
@@ -358,41 +355,6 @@
         }
     }
 
-    private List<String> getSendToDataForIds(long[] ids, String scheme) {
-        final List<String> items = new ArrayList<>();
-        final String sIds = GroupUtil.convertArrayToString(ids);
-        final String select = (ContactsUtils.SCHEME_MAILTO.equals(scheme)
-                ? Query.EMAIL_SELECTION
-                + " AND " + ContactsContract.CommonDataKinds.Email._ID + " IN (" + sIds + ")"
-                : Query.PHONE_SELECTION
-                + " AND " + ContactsContract.CommonDataKinds.Phone._ID + " IN (" + sIds + ")");
-        final ContentResolver contentResolver = getContext().getContentResolver();
-        final Cursor cursor = contentResolver.query(ContactsContract.Data.CONTENT_URI,
-                ContactsUtils.SCHEME_MAILTO.equals(scheme)
-                    ? Query.EMAIL_PROJECTION
-                    : Query.PHONE_PROJECTION,
-                select, null, null);
-
-        if (cursor == null) {
-            return items;
-        }
-
-        try {
-            cursor.moveToPosition(-1);
-            while (cursor.moveToNext()) {
-                final String data = cursor.getString(Query.DATA1);
-
-                if (!TextUtils.isEmpty(data)) {
-                    items.add(data);
-                }
-            }
-        } finally {
-            cursor.close();
-        }
-
-        return items;
-    }
-
     private void sendToGroup(long[] ids, String sendScheme, String title) {
         if (ids == null || ids.length == 0) return;
 
@@ -471,17 +433,13 @@
         }
 
         final String itemsString = TextUtils.join(",", itemList);
-        startSendToSelectionActivity(itemsString, sendScheme, title);
-    }
-
-    private void startSendToSelectionActivity(String listItems, String sendScheme, String title) {
-        startActivity(GroupUtil.createSendToSelectionIntent(listItems, sendScheme, title));
+        GroupUtil.startSendToSelectionActivity(this, itemsString, sendScheme, title);
     }
 
     private void startSendToSelectionPickerActivity(long[] ids, long[] defaultSelection,
             String sendScheme, String title) {
-        startActivityForResult(GroupUtil.createSendToSelectionPickerIntent(getContext(), ids,
-                defaultSelection, sendScheme, title), RESULT_SEND_TO_SELECTION);
+        startActivity(GroupUtil.createSendToSelectionPickerIntent(getContext(), ids,
+                defaultSelection, sendScheme, title));
     }
 
     private void startGroupAddMemberActivity() {
@@ -555,38 +513,25 @@
 
     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (resultCode != Activity.RESULT_OK || data == null) {
+        if (resultCode != Activity.RESULT_OK || data == null
+                || requestCode != RESULT_GROUP_ADD_MEMBER) {
             return;
         }
-        switch(requestCode) {
-            case RESULT_GROUP_ADD_MEMBER: {
-                long[] contactIds = data.getLongArrayExtra(
-                        UiIntentActions.TARGET_CONTACT_IDS_EXTRA_KEY);
-                if (contactIds == null) {
-                    final long contactId = data.getLongExtra(
-                            UiIntentActions.TARGET_CONTACT_ID_EXTRA_KEY, -1);
-                    if (contactId > -1) {
-                        contactIds = new long[1];
-                        contactIds[0] = contactId;
-                    }
-                }
-                new UpdateGroupMembersAsyncTask(
-                        UpdateGroupMembersAsyncTask.TYPE_ADD,
-                        getContext(), contactIds, mGroupMetaData.groupId, mGroupMetaData.accountName,
-                        mGroupMetaData.accountType, mGroupMetaData.dataSet).execute();
-                break;
-            }
-            case RESULT_SEND_TO_SELECTION: {
-                final long[] ids = data.getLongArrayExtra(
-                        UiIntentActions.TARGET_CONTACT_IDS_EXTRA_KEY);
-                final String sendScheme = data.getStringExtra(UiIntentActions.SELECTION_SEND_SCHEME);
-                final String sendTitle = data.getStringExtra(UiIntentActions.SELECTION_SEND_TITLE);
-                final List<String> items = getSendToDataForIds(ids, sendScheme);
-                final String list = TextUtils.join(",", items);
-                startSendToSelectionActivity(list, sendScheme, sendTitle);
-                break;
+
+        long[] contactIds = data.getLongArrayExtra(
+                UiIntentActions.TARGET_CONTACT_IDS_EXTRA_KEY);
+        if (contactIds == null) {
+            final long contactId = data.getLongExtra(
+                    UiIntentActions.TARGET_CONTACT_ID_EXTRA_KEY, -1);
+            if (contactId > -1) {
+                contactIds = new long[1];
+                contactIds[0] = contactId;
             }
         }
+        new UpdateGroupMembersAsyncTask(
+                UpdateGroupMembersAsyncTask.TYPE_ADD,
+                getContext(), contactIds, mGroupMetaData.groupId, mGroupMetaData.accountName,
+                mGroupMetaData.accountType, mGroupMetaData.dataSet).execute();
     }
 
     private final ActionBarAdapter.Listener mActionBarListener = new ActionBarAdapter.Listener() {
diff --git a/src/com/android/contacts/group/GroupUtil.java b/src/com/android/contacts/group/GroupUtil.java
index dc85152..3b79546 100644
--- a/src/com/android/contacts/group/GroupUtil.java
+++ b/src/com/android/contacts/group/GroupUtil.java
@@ -16,6 +16,8 @@
 
 package com.android.contacts.group;
 
+import android.app.Fragment;
+import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
@@ -58,6 +60,8 @@
     public static final String ACTION_SWITCH_GROUP = "switchGroup";
     public static final String ACTION_UPDATE_GROUP = "updateGroup";
 
+    public static final int RESULT_SEND_TO_SELECTION = 100;
+
     // System IDs of FFC groups in Google accounts
     private static final Set<String> FFC_GROUPS =
             new HashSet(Arrays.asList("Friends", "Family", "Coworkers"));
@@ -100,12 +104,48 @@
                 isFirstGroupInAccount, memberCount, isReadOnly, systemId);
     }
 
+    public static List<String> getSendToDataForIds(Context context, long[] ids, String scheme) {
+        final List<String> items = new ArrayList<>();
+        final String sIds = GroupUtil.convertArrayToString(ids);
+        final String select = (ContactsUtils.SCHEME_MAILTO.equals(scheme)
+                ? GroupMembersFragment.Query.EMAIL_SELECTION
+                + " AND " + ContactsContract.CommonDataKinds.Email._ID + " IN (" + sIds + ")"
+                : GroupMembersFragment.Query.PHONE_SELECTION
+                + " AND " + ContactsContract.CommonDataKinds.Phone._ID + " IN (" + sIds + ")");
+        final ContentResolver contentResolver = context.getContentResolver();
+        final Cursor cursor = contentResolver.query(ContactsContract.Data.CONTENT_URI,
+                ContactsUtils.SCHEME_MAILTO.equals(scheme)
+                        ? GroupMembersFragment.Query.EMAIL_PROJECTION
+                        : GroupMembersFragment.Query.PHONE_PROJECTION,
+                select, null, null);
+
+        if (cursor == null) {
+            return items;
+        }
+
+        try {
+            cursor.moveToPosition(-1);
+            while (cursor.moveToNext()) {
+                final String data = cursor.getString(GroupMembersFragment.Query.DATA1);
+
+                if (!TextUtils.isEmpty(data)) {
+                    items.add(data);
+                }
+            }
+        } finally {
+            cursor.close();
+        }
+
+        return items;
+    }
+
     /** Returns an Intent to send emails/phones to some activity/app */
-    public static Intent createSendToSelectionIntent(
-            String itemsList, String sendScheme, String title) {
+    public static void startSendToSelectionActivity(
+            Fragment fragment, String itemsList, String sendScheme, String title) {
         final Intent intent = new Intent(Intent.ACTION_SENDTO,
                 Uri.fromParts(sendScheme, itemsList, null));
-        return Intent.createChooser(intent, title);
+        fragment.startActivityForResult(
+                Intent.createChooser(intent, title), RESULT_SEND_TO_SELECTION);
     }
 
     /** Returns an Intent to pick emails/phones to send to selection (or group) */
diff --git a/src/com/android/contacts/list/MultiSelectEmailAddressesListFragment.java b/src/com/android/contacts/list/MultiSelectEmailAddressesListFragment.java
index d3aa5ca..d14488a 100644
--- a/src/com/android/contacts/list/MultiSelectEmailAddressesListFragment.java
+++ b/src/com/android/contacts/list/MultiSelectEmailAddressesListFragment.java
@@ -15,9 +15,9 @@
  */
 package com.android.contacts.list;
 
-import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;
+import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -27,7 +27,9 @@
 
 import com.android.contacts.R;
 import com.android.contacts.common.logging.ListEvent;
+import com.android.contacts.group.GroupUtil;
 
+import java.util.List;
 import java.util.TreeSet;
 
 /** Displays a list of emails with check boxes. */
@@ -74,6 +76,11 @@
     }
 
     @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        getActivity().finish();
+    }
+
+    @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch(item.getItemId()) {
             case R.id.menu_send: {
@@ -81,13 +88,10 @@
                         UiIntentActions.SELECTION_SEND_SCHEME);
                 final String title= getActivity().getIntent().getStringExtra(
                         UiIntentActions.SELECTION_SEND_TITLE);
-                final Intent intent = new Intent();
-                intent.putExtra(UiIntentActions.TARGET_CONTACT_IDS_EXTRA_KEY,
-                        getAdapter().getSelectedContactIdsArray());
-                intent.putExtra(UiIntentActions.SELECTION_SEND_SCHEME, scheme);
-                intent.putExtra(UiIntentActions.SELECTION_SEND_TITLE, title);
-                getActivity().setResult(Activity.RESULT_OK, intent);
-                getActivity().finish();
+                final List<String> items = GroupUtil.getSendToDataForIds(
+                        getActivity(), getAdapter().getSelectedContactIdsArray(), scheme);
+                final String list = TextUtils.join(",", items);
+                GroupUtil.startSendToSelectionActivity(this, list, scheme, title);
                 return true;
             }
         }
diff --git a/src/com/android/contacts/list/MultiSelectPhoneNumbersListFragment.java b/src/com/android/contacts/list/MultiSelectPhoneNumbersListFragment.java
index aea89e4..5a1a761 100644
--- a/src/com/android/contacts/list/MultiSelectPhoneNumbersListFragment.java
+++ b/src/com/android/contacts/list/MultiSelectPhoneNumbersListFragment.java
@@ -15,9 +15,9 @@
  */
 package com.android.contacts.list;
 
-import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;
+import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -27,7 +27,9 @@
 
 import com.android.contacts.R;
 import com.android.contacts.common.logging.ListEvent;
+import com.android.contacts.group.GroupUtil;
 
+import java.util.List;
 import java.util.TreeSet;
 
 /** Displays a list of phone numbers with check boxes. */
@@ -74,6 +76,11 @@
     }
 
     @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        getActivity().finish();
+    }
+
+    @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch(item.getItemId()) {
             case R.id.menu_send: {
@@ -81,13 +88,10 @@
                         UiIntentActions.SELECTION_SEND_SCHEME);
                 final String title= getActivity().getIntent().getStringExtra(
                         UiIntentActions.SELECTION_SEND_TITLE);
-                final Intent intent = new Intent();
-                intent.putExtra(UiIntentActions.TARGET_CONTACT_IDS_EXTRA_KEY,
-                        getAdapter().getSelectedContactIdsArray());
-                intent.putExtra(UiIntentActions.SELECTION_SEND_SCHEME, scheme);
-                intent.putExtra(UiIntentActions.SELECTION_SEND_TITLE, title);
-                getActivity().setResult(Activity.RESULT_OK, intent);
-                getActivity().finish();
+                final List<String> items = GroupUtil.getSendToDataForIds(
+                        getActivity(), getAdapter().getSelectedContactIdsArray(), scheme);
+                final String list = TextUtils.join(",", items);
+                GroupUtil.startSendToSelectionActivity(this, list, scheme, title);
                 return true;
             }
         }
