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

chrome/android/junit/src/org/chromium/chrome/browser/ntp/cards/NewTabPageAdapterTest.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 static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
@@ skipping 89 matching lines @@
      */
     private static class ItemsMatcher { // TODO(pke): Find better name.
         private final NewTabPageAdapter mAdapter;
         private int mCurrentIndex;
 
         public ItemsMatcher(NewTabPageAdapter adapter, int startingIndex) {
             mAdapter = adapter;
             mCurrentIndex = startingIndex;
         }
 
-        public void expect(@NewTabPageItem.ViewType int expectedItemType) {
+        public void expect(@ItemViewType int expectedItemType) {
             if (mCurrentIndex >= mAdapter.getItemCount()) {
                 fail("Expected item of type " + expectedItemType + " but encountered end of list");
             }
-            @NewTabPageItem.ViewType int itemType = mAdapter.getItemViewType(mCurrentIndex);
+            @ItemViewType int itemType = mAdapter.getItemViewType(mCurrentIndex);
             assertEquals("Type mismatch at position " + mCurrentIndex, expectedItemType, itemType);
             mCurrentIndex++;
         }
 
         public void expect(SectionDescriptor descriptor) {
-            expect(NewTabPageItem.VIEW_TYPE_HEADER);
+            expect(ItemViewType.HEADER);
             if (descriptor.mStatusCard) {
-                expect(NewTabPageItem.VIEW_TYPE_STATUS);
-                expect(NewTabPageItem.VIEW_TYPE_ACTION);
-                expect(NewTabPageItem.VIEW_TYPE_PROGRESS);
+                expect(ItemViewType.STATUS);
+                expect(ItemViewType.ACTION);
+                expect(ItemViewType.PROGRESS);
             } else {
                 for (int i = 1; i <= descriptor.mNumSuggestions; i++) {
-                    expect(NewTabPageItem.VIEW_TYPE_SNIPPET);
+                    expect(ItemViewType.SNIPPET);
                 }
                 if (descriptor.mMoreButton) {
-                    expect(NewTabPageItem.VIEW_TYPE_ACTION);
+                    expect(ItemViewType.ACTION);
                 }
             }
         }
 
         public void expectPosition(int expectedPosition) {
             assertEquals(expectedPosition, mCurrentIndex);
         }
     }
 
     /**
      * Asserts that the given itemGroup is a {@link SuggestionsSection} that matches the given
      * {@link SectionDescriptor}.
      * @param descriptor The section descriptor to match against.
      * @param itemGroup The items from the adapter.
      */
-    private void assertMatches(SectionDescriptor descriptor, ItemGroup itemGroup) {
+    private void assertMatches(SectionDescriptor descriptor, TreeNode itemGroup) {
         int offset = mAdapter.getGroupPositionOffset(itemGroup);
         ItemsMatcher matcher = new ItemsMatcher(mAdapter, offset);
         matcher.expect(descriptor);
-        matcher.expectPosition(offset + itemGroup.getItems().size());
+        matcher.expectPosition(offset + itemGroup.getItemCount());
     }
 
     /**
      * Asserts that {@link #mAdapter}.{@link NewTabPageAdapter#getItemCount()} corresponds to an
      * NTP with the given sections in it.
      * @param descriptors A list of descriptors, each describing a section that should be present on
      *                    the UI.
      */
     private void assertItemsFor(SectionDescriptor... descriptors) {
         ItemsMatcher matcher = new ItemsMatcher(mAdapter, 0);
-        matcher.expect(NewTabPageItem.VIEW_TYPE_ABOVE_THE_FOLD);
+        matcher.expect(ItemViewType.ABOVE_THE_FOLD);
         for (SectionDescriptor descriptor : descriptors) matcher.expect(descriptor);
         if (descriptors.length == 0) {
-            matcher.expect(NewTabPageItem.VIEW_TYPE_ALL_DISMISSED);
+            matcher.expect(ItemViewType.ALL_DISMISSED);
         } else {
-            matcher.expect(NewTabPageItem.VIEW_TYPE_FOOTER);
+            matcher.expect(ItemViewType.FOOTER);
         }
-        matcher.expect(NewTabPageItem.VIEW_TYPE_SPACING);
+        matcher.expect(ItemViewType.SPACING);
         matcher.expectPosition(mAdapter.getItemCount());
     }
 
     /**
      * To be used with {@link #assertItemsFor(SectionDescriptor...)}, for a section with
      * {@code numSuggestions} cards in it.
      * @param numSuggestions The number of suggestions in the section. If there are zero, use either
      *                       no section at all (if it is not displayed) or
      *                       {@link #sectionWithStatusCard()}.
      * @return A descriptor for the section.
@@ skipping 177 matching lines @@
         assertItemsFor(section(4));
     }
 
     /**
      * Tests how the loading indicator reacts to status changes.
      */
     @Test
     @Feature({"Ntp"})
     public void testProgressIndicatorDisplay() {
         int progressPos = mAdapter.getFooterPosition() - 1;
-        SuggestionsSection section = (SuggestionsSection) mAdapter.getGroup(progressPos);
-        List<NewTabPageItem> items = section.getItems();
-        ProgressItem progress = (ProgressItem) items.get(items.size() - 1);
+        SuggestionsSection section = mAdapter.getSuggestionsSection(progressPos);
+        ProgressItem progress = section.getProgressItemForTesting();
 
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.INITIALIZING);
         assertTrue(progress.isVisible());
 
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         assertFalse(progress.isVisible());
 
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE_LOADING);
         assertTrue(progress.isVisible());
 
@@ skipping 228 matching lines @@
     public void testCategoryOrder() {
         final int basicGroupCount = 4; // above-the-fold, sign in promo, footer, spacer.
         FakeSuggestionsSource suggestionsSource = new FakeSuggestionsSource();
         registerCategory(suggestionsSource, KnownCategories.ARTICLES, 0);
         registerCategory(suggestionsSource, KnownCategories.BOOKMARKS, 0);
         registerCategory(suggestionsSource, KnownCategories.PHYSICAL_WEB_PAGES, 0);
         registerCategory(suggestionsSource, KnownCategories.DOWNLOADS, 0);
 
         NewTabPageAdapter ntpAdapter =
                 new NewTabPageAdapter(new MockNewTabPageManager(suggestionsSource), null, null);
-        List<ItemGroup> groups = ntpAdapter.getGroups();
+        List<TreeNode> groups = ntpAdapter.getGroups();
 
         assertEquals(basicGroupCount + 4, groups.size());
         assertEquals(AboveTheFoldItem.class, groups.get(0).getClass());
         assertEquals(SuggestionsSection.class, groups.get(1).getClass());
         assertEquals(KnownCategories.ARTICLES, getCategory(groups.get(1)));
         assertEquals(SuggestionsSection.class, groups.get(2).getClass());
         assertEquals(KnownCategories.BOOKMARKS, getCategory(groups.get(2)));
         assertEquals(SuggestionsSection.class, groups.get(3).getClass());
         assertEquals(KnownCategories.PHYSICAL_WEB_PAGES, getCategory(groups.get(3)));
         assertEquals(SuggestionsSection.class, groups.get(4).getClass());
@@ skipping 125 matching lines @@
     }
 
     @Test
     @Feature({"Ntp"})
     public void testSigninPromo() {
         when(mMockSigninManager.isSignInAllowed()).thenReturn(true);
         when(mMockSigninManager.isSignedInOnNative()).thenReturn(false);
         MockNewTabPageManager ntpManager = new MockNewTabPageManager(mSource);
         NewTabPageAdapter adapter = new NewTabPageAdapter(ntpManager, null, null);
 
-        assertEquals(5, adapter.getGroups().size());
-        ItemGroup signinPromoGroup = adapter.getGroup(5);
+        TreeNode signinPromoGroup = adapter.getGroups().get(2);
 
         // Adapter content:
         // Idx | Item               | Group Index
         // ----|--------------------|-------------
         // 0   | Above-the-fold     | 0
         // 1   | Header             | 1
         // 2   | Status             | 1
         // 3   | Action             | 1
         // 4   | Progress Indicator | 1
         // 5   | Sign in promo      | 2
         // 6   | Footer             | 3
         // 7   | Spacer             | 4
 
-        assertEquals(1, signinPromoGroup.getItems().size());
-        assertEquals(NewTabPageItem.VIEW_TYPE_PROMO, signinPromoGroup.getItems().get(0).getType());
+        assertEquals(1, signinPromoGroup.getItemCount());
+        assertEquals(ItemViewType.PROMO, signinPromoGroup.getItemViewType(0));
 
         ntpManager.mSignInStateObserver.onSignedIn();
-        assertEquals(0, signinPromoGroup.getItems().size());
+        assertEquals(0, signinPromoGroup.getItemCount());
 
         ntpManager.mSignInStateObserver.onSignedOut();
-        assertEquals(1, signinPromoGroup.getItems().size());
+        assertEquals(1, signinPromoGroup.getItemCount());
     }
 
     @Test
     @Feature({"Ntp"})
     public void testSigninPromoDismissal() {
         when(mMockSigninManager.isSignInAllowed()).thenReturn(true);
         when(mMockSigninManager.isSignedInOnNative()).thenReturn(false);
         ChromePreferenceManager.getInstance(RuntimeEnvironment.application)
                 .setNewTabPageSigninPromoDismissed(false);
         MockNewTabPageManager ntpManager = new MockNewTabPageManager(mSource);
         NewTabPageAdapter adapter = new NewTabPageAdapter(ntpManager, null, null);
         final int signInPromoIndex = 5;
 
         assertEquals(5, adapter.getGroups().size());
-        ItemGroup signinPromoGroup = adapter.getGroup(signInPromoIndex);
+        TreeNode signinPromoGroup = adapter.getGroups().get(2);
 
         // Adapter content:
-        // Idx | Item
-        // ----|----------------
-        // 0   | Above-the-fold
-        // 1   | Header
-        // 2   | Status
-        // 3   | Action
-        // 4   | Progress Indicator
-        // 5   | Sign in promo
-        // 6   | Footer
-        // 7   | Spacer
+        // Idx | Item               | Group Index
+        // ----|--------------------|-------------
+        // 0   | Above-the-fold     | 0
+        // 1   | Header             | 1
+        // 2   | Status             | 1
+        // 3   | Action             | 1
+        // 4   | Progress Indicator | 1
+        // 5   | Sign in promo      | 2
+        // 6   | Footer             | 3
+        // 7   | Spacer             | 4
 
-        assertEquals(NewTabPageItem.VIEW_TYPE_PROMO, signinPromoGroup.getItems().get(0).getType());
+        assertEquals(ItemViewType.PROMO, signinPromoGroup.getItemViewType(0));
 
         adapter.dismissItem(signInPromoIndex);
-        assertTrue(signinPromoGroup.getItems().isEmpty());
+        assertEquals(0, signinPromoGroup.getItemCount());
         assertTrue(ChromePreferenceManager.getInstance(RuntimeEnvironment.application)
                            .getNewTabPageSigninPromoDismissed());
 
         adapter = new NewTabPageAdapter(ntpManager, null, null);
         assertEquals(5, adapter.getGroups().size());
         // The items below the signin promo move up, footer is now at the position of the promo.
-        assertEquals(NewTabPageItem.VIEW_TYPE_FOOTER, adapter.getItemViewType(signInPromoIndex));
+        assertEquals(ItemViewType.FOOTER, adapter.getItemViewType(signInPromoIndex));
     }
 
     /** Registers the category with hasMoreButton=false and showIfEmpty=true*/
     private void registerCategory(FakeSuggestionsSource suggestionsSource,
             @CategoryInt int category, int suggestionCount) {
         // FakeSuggestionSource does not provide suggestions if the category's status is not
         // AVAILABLE.
         suggestionsSource.setStatusForCategory(category, CategoryStatus.AVAILABLE);
         // Important: showIfEmpty flag to true.
         suggestionsSource.setInfoForCategory(category, createInfo(category, false, true));
         suggestionsSource.setSuggestionsForCategory(
                 category, createDummySuggestions(suggestionCount));
     }
 
-    private int getCategory(ItemGroup itemGroup) {
+    private int getCategory(TreeNode itemGroup) {
         return ((SuggestionsSection) itemGroup).getCategory();
     }
 
     private static class MockNewTabPageManager implements NewTabPageManager {
         SuggestionsSource mSuggestionsSource;
         SignInStateObserver mSignInStateObserver;
 
         public MockNewTabPageManager(SuggestionsSource suggestionsSource) {
             mSuggestionsSource = suggestionsSource;
         }
@@ skipping 157 matching lines @@
         public void registerSignInStateObserver(SignInStateObserver signInStateObserver) {
             mSignInStateObserver = signInStateObserver;
         }
 
         @Override
         public boolean isCurrentPage() {
             return true;
         }
     }
 }