Unify NewTabPageItem and ItemGroup into a single tree-structured interface.

chrome/android/java/src/org/chromium/chrome/browser/ntp/cards/NewTabPageAdapter.java

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.ntp.cards;
 
 import android.annotation.SuppressLint;
 import android.graphics.Canvas;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.RecyclerView.Adapter;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.support.v7.widget.helper.ItemTouchHelper;
 import android.view.View;
 import android.view.ViewGroup;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ntp.NewTabPageView.NewTabPageManager;
 import org.chromium.chrome.browser.ntp.UiConfig;
 import org.chromium.chrome.browser.ntp.snippets.CategoryInt;
 import org.chromium.chrome.browser.ntp.snippets.CategoryStatus;
 import org.chromium.chrome.browser.ntp.snippets.CategoryStatus.CategoryStatusEnum;
-import org.chromium.chrome.browser.ntp.snippets.SectionHeader;
 import org.chromium.chrome.browser.ntp.snippets.SectionHeaderViewHolder;
 import org.chromium.chrome.browser.ntp.snippets.SnippetArticle;
 import org.chromium.chrome.browser.ntp.snippets.SnippetArticleViewHolder;
 import org.chromium.chrome.browser.ntp.snippets.SnippetsBridge;
 import org.chromium.chrome.browser.ntp.snippets.SuggestionsSource;
 import org.chromium.chrome.browser.signin.SigninManager.SignInStateObserver;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * A class that handles merging above the fold elements and below the fold cards into an adapter
  * that will be used to back the NTP RecyclerView. The first element in the adapter should always be
  * the above-the-fold view (containing the logo, search box, and most visited tiles) and subsequent
  * elements will be the cards shown to the user
  */
-public class NewTabPageAdapter extends Adapter<NewTabPageViewHolder>
-        implements SuggestionsSource.Observer, ItemGroup.Observer {
+public class NewTabPageAdapter
+        extends Adapter<NewTabPageViewHolder> implements SuggestionsSource.Observer, NodeParent {
     private static final String TAG = "Ntp";
 
     private final NewTabPageManager mNewTabPageManager;
     private final View mAboveTheFoldView;
     private final UiConfig mUiConfig;
     private final ItemTouchCallbacks mItemTouchCallbacks = new ItemTouchCallbacks();
     private NewTabPageRecyclerView mRecyclerView;
 
     /**
      * List of all item groups (which can themselves contain multiple items. When flattened, this
      * will be a list of all items the adapter exposes.
      */
-    private final List<ItemGroup> mGroups = new ArrayList<>();
+    private final List<TreeNode> mGroups = new ArrayList<>();
     private final AboveTheFoldItem mAboveTheFold = new AboveTheFoldItem();
-    private final SignInPromo mSigninPromo = new SignInPromo();
+    private final SignInPromo mSigninPromo;
     private final AllDismissedItem mAllDismissed = new AllDismissedItem();
     private final Footer mFooter = new Footer();
     private final SpacingItem mBottomSpacer = new SpacingItem();
+    private final InnerNode mRoot;
 
     /** Maps suggestion categories to sections, with stable iteration ordering. */
     private final Map<Integer, SuggestionsSection> mSections = new LinkedHashMap<>();
 
     private class ItemTouchCallbacks extends ItemTouchHelper.Callback {
         @Override
         public void onSwiped(ViewHolder viewHolder, int direction) {
             mRecyclerView.onItemDismissStarted(viewHolder);
             NewTabPageAdapter.this.dismissItem(viewHolder.getAdapterPosition());
         }
@@ skipping 53 matching lines @@
      *
      * @param manager the NewTabPageManager to use to interact with the rest of the system.
      * @param aboveTheFoldView the layout encapsulating all the above-the-fold elements
      *                         (logo, search box, most visited tiles)
      * @param uiConfig the NTP UI configuration, to be passed to created views.
      */
     public NewTabPageAdapter(NewTabPageManager manager, View aboveTheFoldView, UiConfig uiConfig) {
         mNewTabPageManager = manager;
         mAboveTheFoldView = aboveTheFoldView;
         mUiConfig = uiConfig;
-        mSigninPromo.setObserver(this);
+        mRoot = new InnerNode(this) {
+            @Override
+            protected List<TreeNode> getChildren() {
+                return mGroups;
+            }
+        };
+
+        mSigninPromo = new SignInPromo(mRoot);
         resetSections(/*alwaysAllowEmptySections=*/false);
         mNewTabPageManager.getSuggestionsSource().setObserver(this);
 
         mNewTabPageManager.registerSignInStateObserver(new SignInStateObserver() {
             @Override
             public void onSignedIn() {
                 mSigninPromo.hide();
                 resetSections(/*alwaysAllowEmptySections=*/false);
             }
 
@@ skipping 50 matching lines @@
 
         // Do not show an empty section if not allowed.
         if (suggestions.isEmpty() && !info.showIfEmpty() && !alwaysAllowEmptySections) {
             mSections.remove(category);
             return 0;
         }
 
         // Create the section if needed.
         SuggestionsSection section = mSections.get(category);
         if (section == null) {
-            section = new SuggestionsSection(info, this);
+            section = new SuggestionsSection(mRoot, info);
             mSections.put(category, section);
         }
 
         // Add the new suggestions.
         setSuggestions(category, suggestions, categoryStatus);
 
         return suggestions.size();
     }
 
     /** Returns callbacks to configure the interactions with the RecyclerView's items. */
@@ skipping 59 matching lines @@
         }
     }
 
     @Override
     public void onSuggestionInvalidated(@CategoryInt int category, String idWithinCategory) {
         if (!mSections.containsKey(category)) return;
         mSections.get(category).removeSuggestionById(idWithinCategory);
     }
 
     @Override
-    @NewTabPageItem.ViewType
+    @ItemViewType
     public int getItemViewType(int position) {
-        return getItems().get(position).getType();
+        return mRoot.getItemViewType(position);
     }
 
     @Override
     public NewTabPageViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
         assert parent == mRecyclerView;
 
-        if (viewType == NewTabPageItem.VIEW_TYPE_ABOVE_THE_FOLD) {
-            return new NewTabPageViewHolder(mAboveTheFoldView);
+        switch (viewType) {
+            case ItemViewType.ABOVE_THE_FOLD: {

[dgn, 2016/10/17 09:58:01]

optional nit: why the brackets?

[Bernhard Bauer, 2016/10/17 14:33:46]

Hm, I thought the brace-less style would only be allowed if the return fits on
the same line as the case label (per standard Java style), but I can find other
examples in the code base. OK, done.

+                return new NewTabPageViewHolder(mAboveTheFoldView);
+            }
+            case ItemViewType.HEADER: {
+                return new SectionHeaderViewHolder(mRecyclerView, mUiConfig);
+            }
+            case ItemViewType.SNIPPET: {
+                return new SnippetArticleViewHolder(mRecyclerView, mNewTabPageManager, mUiConfig);
+            }
+            case ItemViewType.SPACING: {
+                return new NewTabPageViewHolder(SpacingItem.createView(parent));
+            }
+            case ItemViewType.STATUS: {
+                return new StatusCardViewHolder(mRecyclerView, mUiConfig);
+            }
+            case ItemViewType.PROGRESS: {
+                return new ProgressViewHolder(mRecyclerView);
+            }
+            case ItemViewType.ACTION: {
+                return new ActionItem.ViewHolder(mRecyclerView, mNewTabPageManager, mUiConfig);
+            }
+            case ItemViewType.PROMO: {
+                return new SignInPromo.ViewHolder(mRecyclerView, mUiConfig);
+            }
+            case ItemViewType.FOOTER: {
+                return new Footer.ViewHolder(mRecyclerView, mNewTabPageManager);
+            }
+            case ItemViewType.ALL_DISMISSED: {
+                return new AllDismissedItem.ViewHolder(mRecyclerView, mNewTabPageManager, this);
+            }
         }
 
-        if (viewType == NewTabPageItem.VIEW_TYPE_HEADER) {
-            return new SectionHeaderViewHolder(mRecyclerView, mUiConfig);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_SNIPPET) {
-            return new SnippetArticleViewHolder(mRecyclerView, mNewTabPageManager, mUiConfig);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_SPACING) {
-            return new NewTabPageViewHolder(SpacingItem.createView(parent));
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_STATUS) {
-            return new StatusCardViewHolder(mRecyclerView, mUiConfig);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_PROGRESS) {
-            return new ProgressViewHolder(mRecyclerView);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_ACTION) {
-            return new ActionItem.ViewHolder(mRecyclerView, mNewTabPageManager, mUiConfig);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_PROMO) {
-            return new SignInPromo.ViewHolder(mRecyclerView, mUiConfig);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_FOOTER) {
-            return new Footer.ViewHolder(mRecyclerView, mNewTabPageManager);
-        }
-
-        if (viewType == NewTabPageItem.VIEW_TYPE_ALL_DISMISSED) {
-            return new AllDismissedItem.ViewHolder(mRecyclerView, mNewTabPageManager, this);
-        }
-
+        assert false : viewType;
         return null;
     }
 
     @Override
     public void onBindViewHolder(NewTabPageViewHolder holder, final int position) {
-        getItems().get(position).onBindViewHolder(holder);
+        mRoot.onBindViewHolder(holder, position);
     }
 
     @Override
     public int getItemCount() {
-        return getItems().size();
+        return mRoot.getItemCount();
     }
 
     public int getAboveTheFoldPosition() {
         return getGroupPositionOffset(mAboveTheFold);
     }
 
     public int getFirstHeaderPosition() {
-        List<NewTabPageItem> items = getItems();
-        for (int i = 0; i < items.size(); i++) {
-            if (items.get(i) instanceof SectionHeader) return i;
+        int count = getItemCount();
+        for (int i = 0; i < count; i++) {
+            if (getItemViewType(i) == ItemViewType.HEADER) return i;
         }
         return RecyclerView.NO_POSITION;
     }
 
     public int getFirstCardPosition() {
         for (int i = 0; i < getItemCount(); ++i) {
             if (CardViewHolder.isCard(getItemViewType(i))) return i;
         }
         return RecyclerView.NO_POSITION;
     }
 
     public int getFooterPosition() {
         return getGroupPositionOffset(mFooter);
     }
 
     public int getBottomSpacerPosition() {
         return getGroupPositionOffset(mBottomSpacer);
     }
 
     public int getSuggestionPosition(SnippetArticle article) {
-        List<NewTabPageItem> items = getItems();
-        for (int i = 0; i < items.size(); i++) {
-            NewTabPageItem item = items.get(i);
-            if (article.equals(item)) return i;
+        for (int i = 0; i < mRoot.getItemCount(); i++) {
+            SnippetArticle articleToCheck = mRoot.getSuggestionAt(i);
+            if (articleToCheck != null && articleToCheck.equals(article)) return i;
         }
         return RecyclerView.NO_POSITION;
     }
 
     /** Start a request for new snippets. */
     public void reloadSnippets() {
         SnippetsBridge.fetchSnippets(/*forceRequest=*/true);
     }
 
     private void setSuggestions(@CategoryInt int category, List<SnippetArticle> suggestions,
@@ skipping 22 matching lines @@
 
         // TODO(mvanouwerkerk): Notify about the subset of changed items. At least |mAboveTheFold|
         // has not changed when refreshing from the all dismissed state.
         notifyDataSetChanged();
     }
 
     private void removeSection(SuggestionsSection section) {
         mSections.remove(section.getCategory());
         int startPos = getGroupPositionOffset(section);
         mGroups.remove(section);
-        notifyItemRangeRemoved(startPos, section.getItems().size());
+        notifyItemRangeRemoved(startPos, section.getItemCount());
 
         if (hasAllBeenDismissed()) {
             int footerPosition = getFooterPosition();
             mGroups.set(mGroups.indexOf(mFooter), mAllDismissed);
             notifyItemChanged(footerPosition);
         }
 
         notifyItemChanged(getBottomSpacerPosition());
     }
 
     @Override
-    public void onItemRangeChanged(ItemGroup group, int itemPosition, int itemCount) {
+    public void onItemRangeChanged(TreeNode child, int itemPosition, int itemCount) {
+        assert child == mRoot;
         if (mGroups.isEmpty()) return; // The sections have not been initialised yet.
-        notifyItemRangeChanged(getGroupPositionOffset(group) + itemPosition, itemCount);
+        notifyItemRangeChanged(itemPosition, itemCount);
     }
 
     @Override
-    public void onItemRangeInserted(ItemGroup group, int itemPosition, int itemCount) {
+    public void onItemRangeInserted(TreeNode child, int itemPosition, int itemCount) {
+        assert child == mRoot;
         if (mGroups.isEmpty()) return; // The sections have not been initialised yet.
-        notifyItemRangeInserted(getGroupPositionOffset(group) + itemPosition, itemCount);
-        notifyItemChanged(getItems().size() - 1); // Refresh the spacer too.
+        notifyItemRangeInserted(itemPosition, itemCount);
+        notifyItemChanged(getItemCount() - 1); // Refresh the spacer too.
     }
 
     @Override
-    public void onItemRangeRemoved(ItemGroup group, int itemPosition, int itemCount) {
+    public void onItemRangeRemoved(TreeNode child, int itemPosition, int itemCount) {
+        assert child == mRoot;
         if (mGroups.isEmpty()) return; // The sections have not been initialised yet.
-        notifyItemRangeRemoved(getGroupPositionOffset(group) + itemPosition, itemCount);
-        notifyItemChanged(getItems().size() - 1); // Refresh the spacer too.
+        notifyItemRangeRemoved(itemPosition, itemCount);
+        notifyItemChanged(getItemCount() - 1); // Refresh the spacer too.
     }
 
     @Override
     public void onAttachedToRecyclerView(RecyclerView recyclerView) {
         super.onAttachedToRecyclerView(recyclerView);
 
         // We are assuming for now that the adapter is used with a single RecyclerView.
         // Getting the reference as we are doing here is going to be broken if that changes.
         assert mRecyclerView == null;
 
         // FindBugs chokes on the cast below when not checked, raising BC_UNCONFIRMED_CAST
         assert recyclerView instanceof NewTabPageRecyclerView;
 
         mRecyclerView = (NewTabPageRecyclerView) recyclerView;
     }
 
     /**
      * Dismisses the item at the provided adapter position. Can also cause the dismissal of other
      * items or even entire sections.
      */
     // TODO(crbug.com/635567): Fix this properly.
     @SuppressLint("SwitchIntDef")
     public void dismissItem(int position) {
         int itemViewType = getItemViewType(position);
 
         // TODO(dgn): Polymorphism is supposed to allow to avoid that kind of stuff.
         switch (itemViewType) {
-            case NewTabPageItem.VIEW_TYPE_STATUS:
-            case NewTabPageItem.VIEW_TYPE_ACTION:
-                dismissSection((SuggestionsSection) getGroup(position));
+            case ItemViewType.STATUS:
+            case ItemViewType.ACTION:
+                dismissSection(getSuggestionsSection(position));
                 return;
 
-            case NewTabPageItem.VIEW_TYPE_SNIPPET:
+            case ItemViewType.SNIPPET:
                 dismissSuggestion(position);
                 return;
 
-            case NewTabPageItem.VIEW_TYPE_PROMO:
+            case ItemViewType.PROMO:
                 dismissPromo();
                 return;
 
             default:
                 Log.wtf(TAG, "Unsupported dismissal of item of type %d", itemViewType);
                 return;
         }
     }
 
     private void dismissSection(SuggestionsSection section) {
         mNewTabPageManager.getSuggestionsSource().dismissCategory(section.getCategory());
         removeSection(section);
     }
 
     private void dismissSuggestion(int position) {
-        SnippetArticle suggestion = (SnippetArticle) getItems().get(position);
-
+        SnippetArticle suggestion = mRoot.getSuggestionAt(position);
         SuggestionsSource suggestionsSource = mNewTabPageManager.getSuggestionsSource();
         if (suggestionsSource == null) {
             // It is possible for this method to be called after the NewTabPage has had destroy()
             // called. This can happen when NewTabPageRecyclerView.dismissWithAnimation() is called
             // and the animation ends after the user has navigated away. In this case we cannot
             // inform the native side that the snippet has been dismissed (http://crbug.com/649299).
             return;
         }
 
         announceItemRemoved(suggestion.mTitle);
 
         suggestionsSource.dismissSuggestion(suggestion);
-        SuggestionsSection section = (SuggestionsSection) getGroup(position);
+        SuggestionsSection section = getSuggestionsSection(position);
         section.removeSuggestion(suggestion);
     }
 
     private void dismissPromo() {
         // TODO(dgn): accessibility announcement.
         mSigninPromo.dismiss();
 
         if (hasAllBeenDismissed()) {
             int footerPosition = getFooterPosition();
             mGroups.set(mGroups.indexOf(mFooter), mAllDismissed);
             notifyItemChanged(footerPosition);
         }
     }
 
     /**
-     * Returns an unmodifiable list containing all items in the adapter.
-     */
-    private List<NewTabPageItem> getItems() {
-        List<NewTabPageItem> items = new ArrayList<>();
-        for (ItemGroup group : mGroups) {
-            items.addAll(group.getItems());
-        }
-        return Collections.unmodifiableList(items);
-    }
-
-    /**
      * Returns another view holder that should be dismissed at the same time as the provided one.
      */
     public ViewHolder getDismissSibling(ViewHolder viewHolder) {
         int swipePos = viewHolder.getAdapterPosition();
-        ItemGroup group = getGroup(swipePos);
+        SuggestionsSection section = getSuggestionsSection(swipePos);
+        if (section == null) return null;
 
-        if (!(group instanceof SuggestionsSection)) return null;
-
-        SuggestionsSection section = (SuggestionsSection) group;
-        int siblingPosDelta = section.getDismissSiblingPosDelta(getItems().get(swipePos));
+        int siblingPosDelta =
+                section.getDismissSiblingPosDelta(swipePos - getGroupPositionOffset(section));
         if (siblingPosDelta == 0) return null;
 
         return mRecyclerView.findViewHolderForAdapterPosition(siblingPosDelta + swipePos);
     }
 
     private boolean hasAllBeenDismissed() {
         return mSections.isEmpty() && !mSigninPromo.isShown();
     }
 
+    /**
+     * @param itemPosition The position of an item in the adapter.
+     * @return Returns the {@link SuggestionsSection} that contains the item at
+     *     {@code itemPosition}, or null if the item is not part of one.
+     */
     @VisibleForTesting
-    ItemGroup getGroup(int itemPosition) {
-        int itemsSkipped = 0;
-        for (ItemGroup group : mGroups) {
-            List<NewTabPageItem> items = group.getItems();
-            itemsSkipped += items.size();
-            if (itemPosition < itemsSkipped) return group;
-        }
-        return null;
+    SuggestionsSection getSuggestionsSection(int itemPosition) {
+        TreeNode child = mGroups.get(mRoot.getChildIndexForPosition(itemPosition));
+        if (!(child instanceof SuggestionsSection)) return null;
+        return (SuggestionsSection) child;
     }
 
     @VisibleForTesting
-    List<ItemGroup> getGroups() {
+    List<TreeNode> getGroups() {
         return Collections.unmodifiableList(mGroups);
     }
 
     @VisibleForTesting
-    int getGroupPositionOffset(ItemGroup group) {
-        int positionOffset = 0;
-        for (ItemGroup candidateGroup : mGroups) {
-            if (candidateGroup == group) return positionOffset;
-            positionOffset += candidateGroup.getItems().size();
-        }
-        Log.d(TAG, "Group not found: %s", group);
-        return RecyclerView.NO_POSITION;
+    int getGroupPositionOffset(TreeNode group) {
+        return mRoot.getStartingOffsetForChild(group);
     }
 
     @VisibleForTesting
     SnippetArticle getSuggestionAt(int position) {
-        return (SnippetArticle) getItems().get(position);
+        return mRoot.getSuggestionAt(position);
     }
 
     private void announceItemRemoved(String suggestionTitle) {
         // In tests the RecyclerView can be null.
         if (mRecyclerView == null) return;
 
         mRecyclerView.announceForAccessibility(mRecyclerView.getResources().getString(
                 R.string.ntp_accessibility_item_removed, suggestionTitle));
     }
 }