diff --git a/res/layout/call_log_list_item.xml b/res/layout/call_log_list_item.xml
index 31dcd88..9a90b24 100644
--- a/res/layout/call_log_list_item.xml
+++ b/res/layout/call_log_list_item.xml
@@ -33,7 +33,7 @@
         android:textColor="?attr/call_log_secondary_text_color"
         android:textSize="@dimen/call_log_secondary_text_size"
         android:paddingTop="@dimen/call_log_day_group_padding"
-        android:paddingBottom="0dp"
+        android:paddingBottom="1dp"
         />
 
     <!-- Linear layout to separate the primary area containing the contact badge and caller
diff --git a/res/layout/call_log_list_item_actions.xml b/res/layout/call_log_list_item_actions.xml
index 3a93575..609f2a9 100644
--- a/res/layout/call_log_list_item_actions.xml
+++ b/res/layout/call_log_list_item_actions.xml
@@ -31,7 +31,6 @@
         <TextView
             android:id="@+id/call_back_action"
             android:background="@drawable/action_button_background"
-            android:fontFamily="sans-serif-medium"
             android:gravity="center"
             android:layout_width="wrap_content"
             android:layout_height="match_parent"
@@ -39,7 +38,8 @@
             android:paddingEnd="@dimen/call_log_action_horizontal_padding"
             android:text="@string/call_log_action_call_back"
             android:textColor="@color/call_log_action_text"
-            android:textSize="@dimen/call_log_secondary_text_size"
+            android:textSize="@dimen/call_log_list_item_actions_text_size"
+            android:textStyle="bold"
             android:nextFocusLeft="@+id/primary_action_view"
             android:nextFocusRight="@+id/voicemail_action"
             android:focusable="true"
@@ -47,7 +47,6 @@
         <TextView
             android:id="@+id/voicemail_action"
             android:background="@drawable/action_button_background"
-            android:fontFamily="sans-serif-medium"
             android:gravity="center"
             android:layout_width="wrap_content"
             android:layout_height="match_parent"
@@ -55,7 +54,8 @@
             android:paddingEnd="@dimen/call_log_action_horizontal_padding"
             android:text="@string/call_log_action_voicemail"
             android:textColor="@color/call_log_action_text"
-            android:textSize="@dimen/call_log_secondary_text_size"
+            android:textSize="@dimen/call_log_list_item_actions_text_size"
+            android:textStyle="bold"
             android:nextFocusLeft="@+id/call_back_action"
             android:nextFocusRight="@+id/details_action"
             android:focusable="true"
@@ -63,7 +63,6 @@
         <TextView
             android:id="@+id/details_action"
             android:background="@drawable/action_button_background"
-            android:fontFamily="sans-serif-medium"
             android:gravity="center"
             android:layout_width="wrap_content"
             android:layout_height="match_parent"
@@ -71,7 +70,8 @@
             android:paddingEnd="@dimen/call_log_action_horizontal_padding"
             android:text="@string/call_log_action_details"
             android:textColor="?attr/call_log_secondary_text_color"
-            android:textSize="@dimen/call_log_secondary_text_size"
+            android:textSize="@dimen/call_log_list_item_actions_text_size"
+            android:textStyle="bold"
             android:nextFocusLeft="@+id/voicemail_action"
             android:nextFocusRight="@+id/primary_action_view"
             android:focusable="true"
diff --git a/res/layout/search_edittext.xml b/res/layout/search_edittext.xml
index 1932228..50cbf5a 100644
--- a/res/layout/search_edittext.xml
+++ b/res/layout/search_edittext.xml
@@ -36,7 +36,8 @@
                 android:layout_margin="@dimen/search_box_icon_margin"
                 android:padding="@dimen/search_box_search_icon_padding"
                 android:src="@drawable/ic_ab_search"
-                android:importantForAccessibility="no" />
+                android:importantForAccessibility="no"
+                android:tint="@color/searchbox_icon_tint" />
 
             <TextView
                 android:layout_width="wrap_content"
@@ -59,7 +60,9 @@
             android:src="@drawable/ic_voice_search"
             android:clickable="true"
             android:contentDescription="@string/description_start_voice_search"
-            android:background="?android:attr/selectableItemBackground" />
+            android:background="?android:attr/selectableItemBackground"
+            android:tint="@color/searchbox_icon_tint" />
+
 
         <ImageButton
             android:id="@+id/dialtacts_options_menu_button"
@@ -69,7 +72,7 @@
             android:background="?android:attr/selectableItemBackground"
             android:src="@drawable/ic_overflow_menu"
             android:contentDescription="@string/action_menu_overflow_description"
-            android:tint="@color/searchbox_options_menu_color" />
+            android:tint="@color/searchbox_icon_tint" />
 
     </LinearLayout>
 
diff --git a/res/layout/show_all_contacts_fragment.xml b/res/layout/show_all_contacts_fragment.xml
index 6b89847..1de5ee5 100644
--- a/res/layout/show_all_contacts_fragment.xml
+++ b/res/layout/show_all_contacts_fragment.xml
@@ -38,10 +38,9 @@
             android:id="@android:id/list"
             android:layout_width="match_parent"
             android:layout_height="match_parent"
-            android:layout_marginLeft="?attr/contact_browser_list_padding_left"
-            android:layout_marginRight="?attr/contact_browser_list_padding_right"
             android:layout_marginStart="?attr/contact_browser_list_padding_left"
             android:layout_marginEnd="?attr/contact_browser_list_padding_right"
+            android:layout_marginTop="18dp"
             android:fastScrollEnabled="true"
             android:fadingEdge="none"
             android:nestedScrollingEnabled="true" />
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 8bba479..42d9118 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -61,8 +61,8 @@
     <!-- Text color of the search box text as entered by user  -->
     <color name="searchbox_text_color">#000000</color>
     <!-- Text color of the search box hint text  -->
-    <color name="searchbox_hint_text_color">#d3d3d3</color>
-    <color name="searchbox_options_menu_color">#d5d5d5</color>
+    <color name="searchbox_hint_text_color">#a4a4a4</color>
+    <color name="searchbox_icon_tint">#a4a4a4</color>
 
     <!-- Color of the contact name in favorite tiles -->
     <color name="contact_tile_name_color">#ffffff</color>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 7318d92..45e48f0 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -64,13 +64,15 @@
 
     <!-- Dimensions for most recent call shortcut cards -->
     <dimen name="recent_call_log_item_translation_z">4dp</dimen>
-    <dimen name="recent_call_log_item_margin">8dp</dimen>
+    <dimen name="recent_call_log_item_margin_horizontal">8dp</dimen>
+    <dimen name="recent_call_log_item_margin_top">4dp</dimen>
     <dimen name="recent_call_log_item_margin_bottom">6dp</dimen>
 
     <!-- The maximum amount to clip on the left and right of the recent call shortcut card -->
     <dimen name="recent_call_log_item_horizontal_clip_limit">20dp</dimen>
     <dimen name="recent_call_log_item_padding_start">8dp</dimen>
-    <dimen name="recent_call_log_item_padding_bottom">7dp</dimen>
+    <dimen name="recent_call_log_item_padding_top">12dp</dimen>
+    <dimen name="recent_call_log_item_padding_bottom">11dp</dimen>
 
     <!-- Size of the star icon on the favorites tile. -->
     <dimen name="favorites_star_icon_size">12dp</dimen>
@@ -114,7 +116,7 @@
     <dimen name="search_box_icon_margin">4dp</dimen>
     <dimen name="search_box_search_icon_padding">4dp</dimen>
     <!-- Left margin of the text field in the search box. -->
-    <dimen name="search_box_text_left_margin">8dp</dimen>
+    <dimen name="search_box_text_left_margin">27dp</dimen>
     <!-- Size of the icon (voice search, close search) in the search box. -->
     <dimen name="search_box_icon_size">28dp</dimen>
     <!-- Elevation of the search box -->
@@ -130,16 +132,14 @@
          call_log_action_horizontal_padding
          call_log_list_contact_photo_size  -->
     <dimen name="call_log_actions_left_padding">64dp</dimen>
-    <!-- Text size for primary call log text -->
     <dimen name="call_log_primary_text_size">16sp</dimen>
-    <!-- Text size for secondary call log text -->
     <dimen name="call_log_secondary_text_size">14sp</dimen>
+    <dimen name="call_log_list_item_actions_text_size">12sp</dimen>
     <!-- Height of the call log actions section for each call log entry -->
-    <dimen name="call_log_action_height">48dp</dimen>
+    <dimen name="call_log_action_height">44dp</dimen>
     <!-- Z Translation of expanded call log items. -->
     <dimen name="call_log_expanded_translation_z">4dp</dimen>
-    <!-- Padding above call log day group headers. -->
-    <dimen name="call_log_day_group_padding">16dp</dimen>
+    <dimen name="call_log_day_group_padding">15dp</dimen>
 
     <!-- Size of icon for contacts number shortcuts -->
     <dimen name="search_shortcut_radius">40dp</dimen>
diff --git a/src/com/android/dialer/list/ShortcutCardsAdapter.java b/src/com/android/dialer/list/ShortcutCardsAdapter.java
index a39bed5..2ce7ea4 100644
--- a/src/com/android/dialer/list/ShortcutCardsAdapter.java
+++ b/src/com/android/dialer/list/ShortcutCardsAdapter.java
@@ -55,9 +55,11 @@
 
     private final ListsFragment mFragment;
 
-    private final int mCallLogMargin;
+    private final int mCallLogMarginHorizontal;
+    private final int mCallLogMarginTop;
     private final int mCallLogMarginBottom;
     private final int mCallLogPaddingStart;
+    private final int mCallLogPaddingTop;
     private final int mCallLogPaddingBottom;
     private final int mCardMaxHorizontalClip;
 
@@ -106,13 +108,18 @@
         final Resources resources = context.getResources();
         mContext = context;
         mFragment = fragment;
-        mCardMaxHorizontalClip = resources.getDimensionPixelSize(
-                R.dimen.recent_call_log_item_horizontal_clip_limit);
-        mCallLogMargin = resources.getDimensionPixelSize(R.dimen.recent_call_log_item_margin);
+        mCardMaxHorizontalClip =
+                resources.getDimensionPixelSize(R.dimen.recent_call_log_item_horizontal_clip_limit);
+        mCallLogMarginHorizontal =
+                resources.getDimensionPixelSize(R.dimen.recent_call_log_item_margin_horizontal);
+        mCallLogMarginTop =
+                resources.getDimensionPixelSize(R.dimen.recent_call_log_item_margin_top);
         mCallLogMarginBottom =
                 resources.getDimensionPixelSize(R.dimen.recent_call_log_item_margin_bottom);
         mCallLogPaddingStart =
                 resources.getDimensionPixelSize(R.dimen.recent_call_log_item_padding_start);
+        mCallLogPaddingTop =
+                resources.getDimensionPixelSize(R.dimen.recent_call_log_item_padding_top);
         mCallLogPaddingBottom =
                 resources.getDimensionPixelSize(R.dimen.recent_call_log_item_padding_bottom);
 
@@ -222,14 +229,20 @@
             final FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
                     FrameLayout.LayoutParams.MATCH_PARENT,
                     FrameLayout.LayoutParams.WRAP_CONTENT);
-            params.setMargins(mCallLogMargin, mCallLogMargin, mCallLogMargin, mCallLogMarginBottom);
+            params.setMargins(
+                    mCallLogMarginHorizontal,
+                    mCallLogMarginTop,
+                    mCallLogMarginHorizontal,
+                    mCallLogMarginBottom);
             view.setLayoutParams(params);
 
             LinearLayout actionView =
                     (LinearLayout)view.findViewById(R.id.primary_action_view);
             actionView.setPaddingRelative(
-                    mCallLogPaddingStart, actionView.getPaddingTop(),
-                    actionView.getPaddingEnd(), mCallLogPaddingBottom);
+                    mCallLogPaddingStart,
+                    mCallLogPaddingTop,
+                    actionView.getPaddingEnd(),
+                    mCallLogPaddingBottom);
 
             view.setTranslationZ(getResources().getDimensionPixelSize(
                     R.dimen.recent_call_log_item_translation_z));
diff --git a/src/com/android/dialer/widget/SearchEditTextLayout.java b/src/com/android/dialer/widget/SearchEditTextLayout.java
index 311d2af..dbb2b22 100644
--- a/src/com/android/dialer/widget/SearchEditTextLayout.java
+++ b/src/com/android/dialer/widget/SearchEditTextLayout.java
@@ -16,13 +16,10 @@
 
 package com.android.dialer.widget;
 
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
 import android.animation.ValueAnimator;
 import android.animation.ValueAnimator.AnimatorUpdateListener;
 import android.content.Context;
 import android.util.AttributeSet;
-import android.util.Log;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.InputMethodManager;
@@ -41,6 +38,8 @@
     private int mLeftMargin;
     private int mRightMargin;
 
+    private float mCollapsedElevation;
+
     /* Subclass-visible for testing */
     protected boolean mIsExpanded = false;
     protected boolean mIsFadedOut = false;
@@ -80,6 +79,8 @@
         mLeftMargin = params.leftMargin;
         mRightMargin = params.rightMargin;
 
+        mCollapsedElevation = getElevation();
+
         mCollapsed = findViewById(R.id.search_box_collapsed);
         mExpanded = findViewById(R.id.search_box_expanded);
         mSearchView = (EditText) mExpanded.findViewById(R.id.search_view);
@@ -160,6 +161,7 @@
         }
 
         setBackgroundResource(R.drawable.search_shadow);
+        setElevation(0);
         if (requestFocus) {
             mSearchView.requestFocus();
         }
@@ -179,6 +181,7 @@
         }
 
         mIsExpanded = false;
+        setElevation(mCollapsedElevation);
         setBackgroundResource(R.drawable.rounded_corner);
     }
 
