diff --git a/go/quickstep/res/layout/icon_recents_root_view.xml b/go/quickstep/res/layout/icon_recents_root_view.xml
index 6fb7e19..ea6fbc2 100644
--- a/go/quickstep/res/layout/icon_recents_root_view.xml
+++ b/go/quickstep/res/layout/icon_recents_root_view.xml
@@ -21,8 +21,9 @@
     android:orientation="vertical">
     <androidx.recyclerview.widget.RecyclerView
         android:id="@+id/recent_task_recycler_view"
-        android:layout_width="match_parent"
+        android:layout_width="@dimen/recents_list_width"
         android:layout_height="match_parent"
+        android:layout_gravity="center_horizontal"
         android:scrollbars="none"/>
     <TextView
         android:id="@+id/recent_task_empty_view"
diff --git a/go/quickstep/res/values/dimens.xml b/go/quickstep/res/values/dimens.xml
index 0be5ee6..60e997a 100644
--- a/go/quickstep/res/values/dimens.xml
+++ b/go/quickstep/res/values/dimens.xml
@@ -15,6 +15,8 @@
      limitations under the License.
 -->
 <resources>
+    <dimen name="recents_list_width">320dp</dimen>
+
     <dimen name="task_item_height">60dp</dimen>
     <dimen name="task_item_top_margin">16dp</dimen>
     <dimen name="task_thumbnail_icon_horiz_margin">16dp</dimen>
@@ -23,5 +25,6 @@
 
     <dimen name="clear_all_item_view_height">36dp</dimen>
     <dimen name="clear_all_item_view_top_margin">20dp</dimen>
+    <dimen name="clear_all_item_view_landscape_bottom_margin">20dp</dimen>
     <dimen name="clear_all_button_width">106dp</dimen>
 </resources>
\ No newline at end of file
diff --git a/go/quickstep/src/com/android/quickstep/views/IconRecentsView.java b/go/quickstep/src/com/android/quickstep/views/IconRecentsView.java
index 1454953..07e5f55 100644
--- a/go/quickstep/src/com/android/quickstep/views/IconRecentsView.java
+++ b/go/quickstep/src/com/android/quickstep/views/IconRecentsView.java
@@ -16,6 +16,7 @@
 package com.android.quickstep.views;
 
 import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
+import static android.content.res.Configuration.ORIENTATION_PORTRAIT;
 
 import static androidx.recyclerview.widget.LinearLayoutManager.VERTICAL;
 
@@ -31,6 +32,8 @@
 import android.animation.PropertyValuesHolder;
 import android.animation.ValueAnimator;
 import android.content.Context;
+import android.content.res.Configuration;
+import android.content.res.Resources;
 import android.graphics.Rect;
 import android.util.ArraySet;
 import android.util.AttributeSet;
@@ -185,16 +188,18 @@
                     // TODO: Determine if current margins cause off screen item to be fully off
                     // screen and if so, modify them so that it is partially off screen.
                     int itemType = parent.getChildViewHolder(view).getItemViewType();
+                    Resources res = getResources();
                     switch (itemType) {
                         case ITEM_TYPE_CLEAR_ALL:
-                            outRect.top = (int) getResources().getDimension(
+                            outRect.top = (int) res.getDimension(
                                     R.dimen.clear_all_item_view_top_margin);
-                            // TODO: In landscape, add bottom margin as well since we won't have
-                            // nav bar to buffer things nicely.
+                            if (res.getConfiguration().orientation == ORIENTATION_LANDSCAPE) {
+                                outRect.bottom = (int) res.getDimension(
+                                        R.dimen.clear_all_item_view_landscape_bottom_margin);
+                            }
                             break;
                         case ITEM_TYPE_TASK:
-                            outRect.top = (int) getResources().getDimension(
-                                    R.dimen.task_item_top_margin);
+                            outRect.top = (int) res.getDimension(R.dimen.task_item_top_margin);
                             break;
                         default:
                     }
@@ -227,6 +232,11 @@
         }
     }
 
+    @Override
+    protected void onConfigurationChanged(Configuration newConfig) {
+        mTaskRecyclerView.invalidateItemDecorations();
+    }
+
     /**
      * Set activity helper for the view to callback to.
      *
