Merge "SDK Manager2 revamp of package display"

2 files changed, 313 insertions, 267 deletions

diff --git a/sdkmanager/libs/sdkuilib/src/com/android/sdkuilib/internal/repository/PackagesPage.java b/sdkmanager/libs/sdkuilib/src/com/android/sdkuilib/internal/repository/PackagesPage.java
index 2652f86..9db8b3d 100755
--- a/sdkmanager/libs/sdkuilib/src/com/android/sdkuilib/internal/repository/PackagesPage.java
+++ b/sdkmanager/libs/sdkuilib/src/com/android/sdkuilib/internal/repository/PackagesPage.java
@@ -33,7 +33,6 @@ import com.android.sdklib.internal.repository.ToolPackage;
 import com.android.sdkuilib.internal.repository.PackageLoader.ISourceLoadedCallback;
 import com.android.sdkuilib.internal.repository.PackageLoader.PkgItem;
 import com.android.sdkuilib.internal.repository.PackageLoader.PkgState;
-import com.android.sdkuilib.internal.repository.PackagesPage.PackagesDiffLogic.UpdateOp;
 import com.android.sdkuilib.internal.repository.icons.ImageFactory;
 import com.android.sdkuilib.repository.ISdkChangeListener;
 import com.android.sdkuilib.ui.GridDataBuilder;
@@ -164,7 +163,8 @@ public class PackagesPage extends UpdaterPage
     }
 
     public void onPageSelected() {
-        if (mDiffLogic.mCurrentCategories == null || mDiffLogic.mCurrentCategories.isEmpty()) {
+        List<PkgCategory> cats = mDiffLogic.getCategories(isSortByApi());
+        if (cats == null || cats.isEmpty()) {
             // Initialize the package list the first time the page is shown.
             loadPackages();
         }
@@ -312,7 +312,7 @@ public class PackagesPage extends UpdaterPage
             public void widgetSelected(SelectionEvent e) {
                 loadPackages();
                 // Reset the expanded state when changing sort algorithm
-                expandInitial(mDiffLogic.mCurrentCategories);
+                expandInitial(mTreeViewer.getInput());
             }
         });
         mCheckSortApi.setText("API level");
@@ -326,7 +326,7 @@ public class PackagesPage extends UpdaterPage
             public void widgetSelected(SelectionEvent e) {
                 loadPackages();
                 // Reset the expanded state when changing sort algorithm
-                expandInitial(mDiffLogic.mCurrentCategories);
+                expandInitial(mTreeViewer.getInput());
             }
         });
 
@@ -531,19 +531,23 @@ public class PackagesPage extends UpdaterPage
         // action done after loadPackages must check the UI hasn't been
         // disposed yet. Otherwise hilarity ensues.
 
-        final boolean useSortByApi = isSortByApi();
+        final boolean displaySortByApi = isSortByApi();
 
         if (!mTreeColumnName.isDisposed()) {
             mTreeColumnName.setImage(
-                    getImage(useSortByApi ? ICON_SORT_BY_API : ICON_SORT_BY_SOURCE));
+                    getImage(displaySortByApi ? ICON_SORT_BY_API : ICON_SORT_BY_SOURCE));
         }
 
-        final UpdateOp op = mDiffLogic.updateStart(useSortByApi);
+        mDiffLogic.updateStart();
         mDiffLogic.mPackageLoader.loadPackages(new ISourceLoadedCallback() {
-            boolean needsRefresh = mDiffLogic.isSortByApi() == useSortByApi;
+            // We'll need to refresh the tree if the tree is not display the categories
+            // for the current sort type.
+            boolean needsRefresh =
+                mTreeViewer.getInput() != mDiffLogic.getCategories(isSortByApi());
 
             public boolean onUpdateSource(SdkSource source, Package[] newPackages) {
-                if (mDiffLogic.updateSourcePackages(op, source, newPackages) || needsRefresh) {
+                if (mDiffLogic.updateSourcePackages(displaySortByApi, source, newPackages) ||
+                        needsRefresh) {
                     refreshViewerSync();
                     needsRefresh = false;
                 }
@@ -555,7 +559,7 @@ public class PackagesPage extends UpdaterPage
             }
 
             public void onLoadCompleted() {
-                if (mDiffLogic.updateEnd(op) || needsRefresh) {
+                if (mDiffLogic.updateEnd(displaySortByApi) || needsRefresh) {
                     refreshViewerSync();
                     needsRefresh = false;
                 }
@@ -572,9 +576,10 @@ public class PackagesPage extends UpdaterPage
                 public void run() {
                     if (!mGroupPackages.isDisposed()) {
 
-                        if (mTreeViewer.getInput() != mDiffLogic.mCurrentCategories) {
+                        List<PkgCategory> cats = mDiffLogic.getCategories(isSortByApi());
+                        if (mTreeViewer.getInput() != cats) {
                             // set initial input
-                            mTreeViewer.setInput(mDiffLogic.mCurrentCategories);
+                            mTreeViewer.setInput(cats);
                         } else {
                             // refresh existing, which preserves the expanded state, the selection
                             // and the checked state.
@@ -582,7 +587,7 @@ public class PackagesPage extends UpdaterPage
                         }
 
                         // set the initial expanded state
-                        expandInitial(mDiffLogic.mCurrentCategories);
+                        expandInitial(mTreeViewer.getInput());
 
                         updateButtonsState();
                         updateMenuCheckmarks();
@@ -797,10 +802,13 @@ public class PackagesPage extends UpdaterPage
         mButtonDelete.setEnabled(canDelete);
     }
 
+    @SuppressWarnings("unchecked")
     private void onSelectNewUpdates() {
         ITreeContentProvider provider = (ITreeContentProvider) mTreeViewer.getContentProvider();
-        synchronized (mDiffLogic.mCurrentCategories) {
-            for (PkgCategory cat : mDiffLogic.mCurrentCategories) {
+
+        List<PkgCategory> cats = (List<PkgCategory>) mTreeViewer.getInput();
+        synchronized (cats) {
+            for (PkgCategory cat : cats) {
                 boolean selected = false;
                 for (PkgItem item : cat.getItems()) {
                     if (item.getState() == PkgState.NEW || item.hasUpdatePkg()) {
@@ -1073,7 +1081,8 @@ public class PackagesPage extends UpdaterPage
         }
 
         private PkgCategory findCategoryForItem(PkgItem item) {
-            for (PkgCategory cat : mDiffLogic.mCurrentCategories) {
+            List<PkgCategory> cats = mDiffLogic.getCategories(isSortByApi());
+            for (PkgCategory cat : cats) {
                 for (PkgItem i : cat.getItems()) {
                     if (i == item) {
                         return cat;
@@ -1423,10 +1432,6 @@ public class PackagesPage extends UpdaterPage
         final PackageLoader mPackageLoader;
         final UpdaterData mUpdaterData;
 
-        final List<PkgCategory> mApiCategories = new ArrayList<PkgCategory>();
-        final List<PkgCategory> mSourceCategories = new ArrayList<PkgCategory>();
-        List<PkgCategory> mCurrentCategories = mApiCategories;
-
         public PackagesDiffLogic(UpdaterData updaterData) {
             mUpdaterData = updaterData;
             mPackageLoader = new PackageLoader(updaterData);
@@ -1436,78 +1441,113 @@ public class PackagesPage extends UpdaterPage
          * An update operation, customized to either sort by API or sort by source.
          */
         abstract class UpdateOp {
-            public final Set<SdkSource> mVisitedSources = new HashSet<SdkSource>();
+            private final Set<SdkSource> mVisitedSources = new HashSet<SdkSource>();
+            protected final List<PkgCategory> mCategories = new ArrayList<PkgCategory>();
+
+            /** Retrieve the sorted category list. */
+            public List<PkgCategory> getCategories() {
+                return mCategories;
+            }
 
             /** Retrieve the category key for the given package, either local or remote. */
             public abstract Object getCategoryKey(Package pkg);
+
             /** Modified {@code currentCategories} to add default categories. */
-            public abstract void addDefaultCategories(List<PkgCategory> currentCategories);
+            public abstract void addDefaultCategories();
+
             /** Creates the category for the given key and returns it. */
             public abstract PkgCategory createCategory(Object catKey);
+
             /** Sorts the category list (but not the items within the categories.) */
-            public abstract void sortCategoryList(List<PkgCategory> categoryList);
+            public abstract void sortCategoryList();
+
             /** Called after items of a given category have changed. Used to sort the
              * items and/or adjust the category name. */
-            public abstract void postCategoryItemsChanged(List<PkgCategory> categoryList);
+            public abstract void postCategoryItemsChanged();
+
             /** Add the new package or merge it as an update or does nothing if this package
              * is already part of the category items.
              * Returns true if the category item list has changed. */
             public abstract boolean mergeNewPackage(Package newPackage, PkgCategory cat);
-        }
 
-        public boolean isSortByApi() {
-            return mCurrentCategories == mApiCategories;
-        }
+            public void updateStart() {
+                mVisitedSources.clear();
 
-        public UpdateOp updateStart(boolean sortByApi) {
-            mCurrentCategories = sortByApi ? mApiCategories : mSourceCategories;
+                // Note that default categories are created after the unused ones so that
+                // the callback can decide whether they should be marked as unused or not.
+                for (PkgCategory cat : mCategories) {
+                    cat.setUnused(true);
+                }
 
-            UpdateOp info = sortByApi ? (new UpdateOpApi()) : (new UpdateOpSource());
+                addDefaultCategories();
+            }
 
-            // Note that default categories are created after the unused ones so that
-            // the callback can decide whether they should be marked as unused or not.
-            for (PkgCategory cat : mCurrentCategories) {
-                cat.setUnused(true);
+            public boolean updateSourcePackages(SdkSource source, Package[] newPackages) {
+                if (newPackages.length > 0) {
+                    mVisitedSources.add(source);
+                }
+                if (source == null) {
+                    return processLocals(this, newPackages);
+                } else {
+                    return processSource(this, source, newPackages);
+                }
             }
 
-            info.addDefaultCategories(mCurrentCategories);
+            public boolean updateEnd() {
+                boolean hasChanged = false;
 
-            return info;
-        }
+                // Remove unused categories
+                synchronized (mCategories) {
+                    for (Iterator<PkgCategory> catIt = mCategories.iterator(); catIt.hasNext(); ) {
+                        PkgCategory cat = catIt.next();
+                        if (cat.isUnused()) {
+                            catIt.remove();
+                            hasChanged  = true;
+                            continue;
+                        }
 
-        public boolean updateSourcePackages(UpdateOp op, SdkSource source, Package[] newPackages) {
-            if (newPackages.length > 0) {
-                op.mVisitedSources.add(source);
-            }
-            if (source == null) {
-                return processLocals(op, newPackages);
-            } else {
-                return processSource(op, source, newPackages);
+                        // Remove all items which obsolete source we have not been visited.
+                        for (Iterator<PkgItem> itemIt = cat.getItems().iterator();
+                                itemIt.hasNext(); ) {
+                            PkgItem item = itemIt.next();
+                            if (!mVisitedSources.contains(item.getSource())) {
+                                itemIt.remove();
+                                hasChanged  = true;
+                            }
+                        }
+                    }
+                }
+                return hasChanged;
             }
+
         }
 
-        public boolean updateEnd(UpdateOp op) {
-            boolean hasChanged = false;
+        private final UpdateOpApi    mOpApi    = new UpdateOpApi();
+        private final UpdateOpSource mOpSource = new UpdateOpSource();
 
-            // Remove unused categories
-            for (Iterator<PkgCategory> catIt = mCurrentCategories.iterator(); catIt.hasNext(); ) {
-                PkgCategory cat = catIt.next();
-                if (cat.isUnused()) {
-                    catIt.remove();
-                    hasChanged  = true;
-                    continue;
-                }
+        public List<PkgCategory> getCategories(boolean displayIsSortByApi) {
+            return displayIsSortByApi ? mOpApi.getCategories() : mOpSource.getCategories();
+        }
 
-                // Remove all items which source we have not been visited. They are obsolete.
-                for (Iterator<PkgItem> itemIt = cat.getItems().iterator(); itemIt.hasNext(); ) {
-                    PkgItem item = itemIt.next();
-                    if (!op.mVisitedSources.contains(item.getSource())) {
-                        itemIt.remove();
-                        hasChanged  = true;
-                    }
-                }
-            }
-            return hasChanged;
+        public void updateStart() {
+            mOpApi.updateStart();
+            mOpSource.updateStart();
+        }
+
+        public boolean updateSourcePackages(
+                boolean displayIsSortByApi,
+                SdkSource source,
+                Package[] newPackages) {
+
+            boolean apiListChanged = mOpApi.updateSourcePackages(source, newPackages);
+            boolean sourceListChanged = mOpSource.updateSourcePackages(source, newPackages);
+            return displayIsSortByApi ? apiListChanged : sourceListChanged;
+        }
+
+        public boolean updateEnd(boolean displayIsSortByApi) {
+            boolean apiListChanged = mOpApi.updateEnd();
+            boolean sourceListChanged = mOpSource.updateEnd();
+            return displayIsSortByApi ? apiListChanged : sourceListChanged;
         }
 
         /** Process all local packages. Returns true if something changed.
@@ -1520,7 +1560,7 @@ public class PackagesPage extends UpdaterPage
             assert newPackages.size() == packages.length;
 
             // Upgrade 'new' items to 'installed' for any local package we already know about
-            for (PkgCategory cat : mCurrentCategories) {
+            for (PkgCategory cat : op.getCategories()) {
                 List<PkgItem> items = cat.getItems();
                 for (int i = 0; i < items.size(); i++) {
                     PkgItem item = items.get(i);
@@ -1548,7 +1588,7 @@ public class PackagesPage extends UpdaterPage
             }
 
             // Downgrade 'installed' items to 'new' if their package isn't listed anymore
-            for (PkgCategory cat : mCurrentCategories) {
+            for (PkgCategory cat : op.getCategories()) {
                 for (PkgItem item : cat.getItems()) {
                     if (item.getState() == PkgState.INSTALLED &&
                             !newPackages.contains(item.getMainPackage())) {
@@ -1561,13 +1601,13 @@ public class PackagesPage extends UpdaterPage
             // Create new 'installed' items for any local package we haven't processed yet
             for (Package newPackage : unusedPackages) {
                 Object catKey = op.getCategoryKey(newPackage);
-                PkgCategory cat = findCurrentCategory(mCurrentCategories, catKey);
+                PkgCategory cat = findCurrentCategory(op.getCategories(), catKey);
 
                 if (cat == null) {
                     // This is a new category. Create it and add it to the list.
                     cat = op.createCategory(catKey);
-                    mCurrentCategories.add(cat);
-                    op.sortCategoryList(mCurrentCategories);
+                    op.getCategories().add(cat);
+                    op.sortCategoryList();
                 }
 
                 cat.getItems().add(new PkgItem(newPackage, PkgState.INSTALLED));
@@ -1576,7 +1616,7 @@ public class PackagesPage extends UpdaterPage
             }
 
             if (hasChanged) {
-                op.postCategoryItemsChanged(mCurrentCategories);
+                op.postCategoryItemsChanged();
             }
 
             return hasChanged;
@@ -1593,7 +1633,7 @@ public class PackagesPage extends UpdaterPage
             assert newPackages.size() == packages.length;
 
             // Remove any items or updates that are no longer in the source's packages
-            for (PkgCategory cat : mCurrentCategories) {
+            for (PkgCategory cat : op.getCategories()) {
                 List<PkgItem> items = cat.getItems();
                 for (int i = 0; i < items.size(); i++) {
                     PkgItem item = items.get(i);
@@ -1631,13 +1671,13 @@ public class PackagesPage extends UpdaterPage
             // Add any new unknown packages
             for (Package newPackage : unusedPackages) {
                 Object catKey = op.getCategoryKey(newPackage);
-                PkgCategory cat = findCurrentCategory(mCurrentCategories, catKey);
+                PkgCategory cat = findCurrentCategory(op.getCategories(), catKey);
 
                 if (cat == null) {
                     // This is a new category. Create it and add it to the list.
                     cat = op.createCategory(catKey);
-                    mCurrentCategories.add(cat);
-                    op.sortCategoryList(mCurrentCategories);
+                    op.getCategories().add(cat);
+                    op.sortCategoryList();
                 }
 
                 // Add the new package or merge it as an update
@@ -1645,7 +1685,7 @@ public class PackagesPage extends UpdaterPage
             }
 
             if (hasChanged) {
-                op.postCategoryItemsChanged(mCurrentCategories);
+                op.postCategoryItemsChanged();
             }
 
             return hasChanged;
@@ -1682,11 +1722,11 @@ public class PackagesPage extends UpdaterPage
             }
 
             @Override
-            public void addDefaultCategories(List<PkgCategory> currentCategories) {
+            public void addDefaultCategories() {
                 boolean needTools = true;
                 boolean needExtras = true;
 
-                for (PkgCategory cat : currentCategories) {
+                for (PkgCategory cat : mCategories) {
                     if (cat.getKey().equals(PkgApiCategory.KEY_TOOLS)) {
                         // Mark them as no unused to prevent their removal in updateEnd().
                         cat.setUnused(false);
@@ -1703,7 +1743,9 @@ public class PackagesPage extends UpdaterPage
                             PkgApiCategory.KEY_TOOLS,
                             null,
                             mUpdaterData.getImageFactory().getImageByName(ICON_CAT_OTHER));
-                    currentCategories.add(acat);
+                    synchronized (mCategories) {
+                        mCategories.add(acat);
+                    }
                 }
 
                 if (needExtras) {
@@ -1711,7 +1753,9 @@ public class PackagesPage extends UpdaterPage
                             PkgApiCategory.KEY_EXTRA,
                             null,
                             mUpdaterData.getImageFactory().getImageByName(ICON_CAT_OTHER));
-                    currentCategories.add(acat);
+                    synchronized (mCategories) {
+                        mCategories.add(acat);
+                    }
                 }
             }
 
@@ -1774,28 +1818,30 @@ public class PackagesPage extends UpdaterPage
             }
 
             @Override
-            public void sortCategoryList(List<PkgCategory> categoryList) {
+            public void sortCategoryList() {
                 // Sort the categories list.
                 // We always want categories in order tools..platforms..extras.
                 // For platform, we compare in descending order (o2-o1).
                 // This order is achieved by having the category keys ordered as
                 // needed for the sort to just do what we expect.
 
-                Collections.sort(categoryList, new Comparator<PkgCategory>() {
-                    public int compare(PkgCategory cat1, PkgCategory cat2) {
-                        assert cat1 instanceof PkgApiCategory;
-                        assert cat2 instanceof PkgApiCategory;
-                        int api1 = ((Integer) cat1.getKey()).intValue();
-                        int api2 = ((Integer) cat2.getKey()).intValue();
-                        return api2 - api1;
-                    }
-                });
+                synchronized (mCategories) {
+                    Collections.sort(mCategories, new Comparator<PkgCategory>() {
+                        public int compare(PkgCategory cat1, PkgCategory cat2) {
+                            assert cat1 instanceof PkgApiCategory;
+                            assert cat2 instanceof PkgApiCategory;
+                            int api1 = ((Integer) cat1.getKey()).intValue();
+                            int api2 = ((Integer) cat2.getKey()).intValue();
+                            return api2 - api1;
+                        }
+                    });
+                }
             }
 
             @Override
-            public void postCategoryItemsChanged(List<PkgCategory> categoryList) {
+            public void postCategoryItemsChanged() {
                 // Sort the items
-                for (PkgCategory cat : mCurrentCategories) {
+                for (PkgCategory cat : mCategories) {
                     Collections.sort(cat.getItems());
 
                     // When sorting by API, we can't always get the platform name
@@ -1841,8 +1887,8 @@ public class PackagesPage extends UpdaterPage
             }
 
             @Override
-            public void addDefaultCategories(List<PkgCategory> currentCategories) {
-                for (PkgCategory cat : currentCategories) {
+            public void addDefaultCategories() {
+                for (PkgCategory cat : mCategories) {
                     if (cat.getKey().equals(PkgSourceCategory.UNKNOWN_SOURCE)) {
                         // Already present.
                         return;
@@ -1855,7 +1901,9 @@ public class PackagesPage extends UpdaterPage
                         mUpdaterData);
                 // Mark it as unused so that it can be cleared in updateEnd() if not used.
                 cat.setUnused(true);
-                currentCategories.add(cat);
+                synchronized (mCategories) {
+                    mCategories.add(cat);
+                }
             }
 
             @Override
@@ -1892,36 +1940,38 @@ public class PackagesPage extends UpdaterPage
             }
 
             @Override
-            public void sortCategoryList(List<PkgCategory> categoryList) {
+            public void sortCategoryList() {
                 // Sort the sources in ascending source name order,
                 // with the local packages always first.
 
-                Collections.sort(categoryList, new Comparator<PkgCategory>() {
-                    public int compare(PkgCategory cat1, PkgCategory cat2) {
-                        assert cat1 instanceof PkgSourceCategory;
-                        assert cat2 instanceof PkgSourceCategory;
-
-                        SdkSource src1 = ((PkgSourceCategory) cat1).getSource();
-                        SdkSource src2 = ((PkgSourceCategory) cat2).getSource();
-
-                        if (src1 == src2) {
-                            return 0;
-                        } else if (src1 == PkgSourceCategory.UNKNOWN_SOURCE) {
-                            return -1;
-                        } else if (src2 == PkgSourceCategory.UNKNOWN_SOURCE) {
-                            return 1;
+                synchronized (mCategories) {
+                    Collections.sort(mCategories, new Comparator<PkgCategory>() {
+                        public int compare(PkgCategory cat1, PkgCategory cat2) {
+                            assert cat1 instanceof PkgSourceCategory;
+                            assert cat2 instanceof PkgSourceCategory;
+
+                            SdkSource src1 = ((PkgSourceCategory) cat1).getSource();
+                            SdkSource src2 = ((PkgSourceCategory) cat2).getSource();
+
+                            if (src1 == src2) {
+                                return 0;
+                            } else if (src1 == PkgSourceCategory.UNKNOWN_SOURCE) {
+                                return -1;
+                            } else if (src2 == PkgSourceCategory.UNKNOWN_SOURCE) {
+                                return 1;
+                            }
+                            assert src1 != null; // true because LOCAL_SOURCE==null
+                            assert src2 != null;
+                            return src1.toString().compareTo(src2.toString());
                         }
-                        assert src1 != null; // true because LOCAL_SOURCE==null
-                        assert src2 != null;
-                        return src1.toString().compareTo(src2.toString());
-                    }
-                });
+                    });
+                }
             }
 
             @Override
-            public void postCategoryItemsChanged(List<PkgCategory> categoryList) {
+            public void postCategoryItemsChanged() {
                 // Sort the items
-                for (PkgCategory cat : mCurrentCategories) {
+                for (PkgCategory cat : mCategories) {
                     Collections.sort(cat.getItems());
                 }
             }
diff --git a/sdkmanager/libs/sdkuilib/tests/com/android/sdkuilib/internal/repository/PackagesDiffLogicTest.java b/sdkmanager/libs/sdkuilib/tests/com/android/sdkuilib/internal/repository/PackagesDiffLogicTest.java
index 3be5d4f..f16f43c 100755
--- a/sdkmanager/libs/sdkuilib/tests/com/android/sdkuilib/internal/repository/PackagesDiffLogicTest.java
+++ b/sdkmanager/libs/sdkuilib/tests/com/android/sdkuilib/internal/repository/PackagesDiffLogicTest.java
@@ -27,7 +27,6 @@ import com.android.sdklib.internal.repository.SdkSource;
 import com.android.sdkuilib.internal.repository.PackageLoader.PkgItem;
 import com.android.sdkuilib.internal.repository.PackagesPage.PackagesDiffLogic;
 import com.android.sdkuilib.internal.repository.PackagesPage.PkgCategory;
-import com.android.sdkuilib.internal.repository.PackagesPage.PackagesDiffLogic.UpdateOp;
 
 import junit.framework.TestCase;
 
@@ -60,25 +59,23 @@ public class PackagesDiffLogicTest extends TestCase {
     // reloaded and is processed at once.
 
     public void testSortByApi_Empty() {
-        UpdateOp op = m.updateStart(true /*sortByApi*/);
-        assertFalse(m.updateSourcePackages(op, null /*locals*/, new Package[0]));
-        assertFalse(m.updateEnd(op));
-
-        assertSame(m.mCurrentCategories, m.mApiCategories);
+        m.updateStart();
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[0]));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         // We also keep these 2 categories even if they contain nothing
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=0>\n",
-               getTree(m));
+               getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_AddSamePackage() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
-        UpdateOp op = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // First insert local packages
-        assertTrue(m.updateSourcePackages(op, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "some pkg", 1)
         }));
 
@@ -86,29 +83,29 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'some pkg' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Insert the next source
         // Same package as the one installed, so we don't display it
-        assertFalse(m.updateSourcePackages(op, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "some pkg", 1)
         }));
 
-        assertFalse(m.updateEnd(op));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'some pkg' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_AddOtherPackage() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
-        UpdateOp op = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // First insert local packages
-        assertTrue(m.updateSourcePackages(op, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "some pkg", 1)
         }));
 
@@ -116,22 +113,22 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'some pkg' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Insert the next source
         // Not the same package as the one installed, so we'll display it
-        assertTrue(m.updateSourcePackages(op, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "other pkg", 1)
         }));
 
-        assertFalse(m.updateEnd(op));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=2>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'some pkg' rev=1>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'other pkg' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_Update1() {
@@ -139,9 +136,9 @@ public class PackagesDiffLogicTest extends TestCase {
 
         // Typical case: user has a locally installed package in revision 1
         // The display list after sort should show that installed package.
-        UpdateOp op = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // First insert local packages
-        assertTrue(m.updateSourcePackages(op, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
 
@@ -149,157 +146,157 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
-        assertTrue(m.updateSourcePackages(op, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 4),
                 new MockEmptyPackage(src1, "type1", 2)
         }));
 
-        assertFalse(m.updateEnd(op));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=4>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_Reload() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
         // First load reveals a package local package and its update
-        UpdateOp op1 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // First insert local packages
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2)
         }));
 
-        assertFalse(m.updateEnd(op1));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Now simulate a reload that clears the package list and create similar
         // objects but not the same references. The only difference is that updateXyz
         // returns false since they don't change anything.
 
-        UpdateOp op2 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // First insert local packages
-        assertFalse(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
-        assertFalse(m.updateSourcePackages(op2, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2)
         }));
 
-        assertFalse(m.updateEnd(op2));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_InstallPackage() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
         // First load reveals a new package
-        UpdateOp op1 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // No local packages at first
-        assertFalse(m.updateSourcePackages(op1, null /*locals*/, new Package[0]));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[0]));
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
 
-        assertFalse(m.updateEnd(op1));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Install it.
-        UpdateOp op2 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // local packages
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
-        assertFalse(m.updateSourcePackages(op2, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
 
-        assertFalse(m.updateEnd(op2));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Load reveals an update
-        UpdateOp op3 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // local packages
-        assertFalse(m.updateSourcePackages(op3, null /*locals*/, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
-        assertTrue(m.updateSourcePackages(op3, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2)
         }));
 
-        assertFalse(m.updateEnd(op3));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_DeletePackage() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
         // We have an installed package
-        UpdateOp op2 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // local packages
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
-        assertTrue(m.updateSourcePackages(op2, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2)
         }));
 
-        assertFalse(m.updateEnd(op2));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // User now deletes the installed package.
-        UpdateOp op1 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         // No local packages
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[0]));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[0]));
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1)
         }));
 
-        assertFalse(m.updateEnd(op1));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=0>\n" +
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=1>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     public void testSortByApi_CompleteUpdate() {
@@ -313,20 +310,20 @@ public class PackagesDiffLogicTest extends TestCase {
         // the final order we get.
 
         // First update has the typical tools and a couple extras
-        UpdateOp op1 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
 
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
         }));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
                 new MockExtraPackage(src1, "android", "usb_driver", 5, 3),
         }));
-        assertFalse(m.updateEnd(op1));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=2>\n" +
@@ -335,14 +332,14 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=2>\n" +
                 "-- <INSTALLED, pkg:Android USB Driver package, revision 4, updated by:Android USB Driver package, revision 5>\n" +
                 "-- <NEW, pkg:Carrier Custom Rom package, revision 1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Next update adds platforms and addon, sorted in a category based on their API level
-        UpdateOp op2 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
         MockPlatformPackage p1;
         MockPlatformPackage p2;
 
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
@@ -351,7 +348,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockPlatformPackage(src1, 3, 6, 3),
                 new MockAddonPackage(src2, "addon A", p1, 5),
         }));
-        assertTrue(m.updateSourcePackages(op2, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
@@ -359,7 +356,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 // second update
                 p2 = new MockPlatformPackage(src1, 2, 4, 3),    // API 2
         }));
-        assertTrue(m.updateSourcePackages(op2, src2, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src2, new Package[] {
                 new MockAddonPackage(src2, "addon C", p2, 9),
                 new MockAddonPackage(src2, "addon A", p1, 6),
                 new MockAddonPackage(src2, "addon B", p2, 7),
@@ -367,7 +364,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockAddonPackage(src2, "addon B", p2, 8),
                 new MockAddonPackage(src2, "addon B", p2, 9),
         }));
-        assertFalse(m.updateEnd(op2));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=2>\n" +
@@ -385,13 +382,13 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=2>\n" +
                 "-- <INSTALLED, pkg:Android USB Driver package, revision 4, updated by:Android USB Driver package, revision 5>\n" +
                 "-- <NEW, pkg:Carrier Custom Rom package, revision 1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
 
         // Reloading the same thing should have no impact except for the update methods
         // returning false when they don't change the current list.
-        UpdateOp op3 = m.updateStart(true /*sortByApi*/);
+        m.updateStart();
 
-        assertFalse(m.updateSourcePackages(op3, null /*locals*/, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
@@ -400,7 +397,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockPlatformPackage(src1, 3, 6, 3),
                 new MockAddonPackage(src2, "addon A", p1, 5),
         }));
-        assertFalse(m.updateSourcePackages(op3, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(true /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
@@ -408,7 +405,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 // second update
                 p2 = new MockPlatformPackage(src1, 2, 4, 3),
         }));
-        assertTrue(m.updateSourcePackages(op3, src2, new Package[] {
+        assertTrue(m.updateSourcePackages(true /*sortByApi*/, src2, new Package[] {
                 new MockAddonPackage(src2, "addon C", p2, 9),
                 new MockAddonPackage(src2, "addon A", p1, 6),
                 new MockAddonPackage(src2, "addon B", p2, 7),
@@ -418,7 +415,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockAddonPackage(src2, "addon B", p2, 8),
                 new MockAddonPackage(src2, "addon B", p2, 9),
         }));
-        assertFalse(m.updateEnd(op3));
+        assertFalse(m.updateEnd(true /*sortByApi*/));
 
         assertEquals(
                 "PkgApiCategory <API=TOOLS, label=Tools, #items=2>\n" +
@@ -436,23 +433,22 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgApiCategory <API=EXTRAS, label=Extras, #items=2>\n" +
                 "-- <INSTALLED, pkg:Android USB Driver package, revision 4, updated by:Android USB Driver package, revision 5>\n" +
                 "-- <NEW, pkg:Carrier Custom Rom package, revision 1>\n",
-               getTree(m));
+                getTree(m, true /*displaySortByApi*/));
     }
 
     // ----
 
     public void testSortBySource_Empty() {
-        UpdateOp op = m.updateStart(false /*sortByApi*/);
-        assertFalse(m.updateSourcePackages(op, null /*locals*/, new Package[0]));
+        m.updateStart();
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[0]));
         // UpdateEnd returns true since it removed the synthetic "unknown source" category
-        assertTrue(m.updateEnd(op));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
-        assertSame(m.mCurrentCategories, m.mSourceCategories);
-        assertTrue(m.mApiCategories.isEmpty());
+        assertTrue(m.getCategories(false /*sortByApi*/).isEmpty());
 
         assertEquals(
                 "",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_AddPackages() {
@@ -461,8 +457,8 @@ public class PackagesDiffLogicTest extends TestCase {
         // which we don't know the source.
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
-        UpdateOp op = m.updateStart(false /*sortByApi*/);
-        assertTrue(m.updateSourcePackages(op, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "known source", 2),
                 new MockEmptyPackage(null, "unknown source", 3),
         }));
@@ -472,13 +468,13 @@ public class PackagesDiffLogicTest extends TestCase {
                 "-- <INSTALLED, pkg:MockEmptyPackage 'unknown source' rev=3>\n" +
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'known source' rev=2>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
-        assertTrue(m.updateSourcePackages(op, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "new", 1),
         }));
 
-        assertFalse(m.updateEnd(op));
+        assertFalse(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=Local Packages (no.source), #items=1>\n" +
@@ -486,7 +482,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgSourceCategory <source=repo1 (repo.com), #items=2>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'new' rev=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'known source' rev=2>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_Update1() {
@@ -494,8 +490,8 @@ public class PackagesDiffLogicTest extends TestCase {
         // Typical case: user has a locally installed package in revision 1
         // The display list after sort should show that instaled package.
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
-        UpdateOp op = m.updateStart(false /*sortByApi*/);
-        assertTrue(m.updateSourcePackages(op, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
 
@@ -503,140 +499,140 @@ public class PackagesDiffLogicTest extends TestCase {
                 "PkgSourceCategory <source=Local Packages (no.source), #items=0>\n" +
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // Edge case: the source reveals an update in revision 2. It is ignored since
         // we already have a package in rev 4.
 
-        assertTrue(m.updateSourcePackages(op, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 4),
                 new MockEmptyPackage(src1, "type1", 2),
         }));
 
-        assertTrue(m.updateEnd(op));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=4>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_Reload() {
 
         // First load reveals a package local package and its update
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
-        UpdateOp op1 = m.updateStart(false /*sortByApi*/);
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2),
         }));
-        assertTrue(m.updateEnd(op1));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // Now simulate a reload that clears the package list and creates similar
         // objects but not the same references. Update methods return false since
         // they don't change anything.
-        UpdateOp op2 = m.updateStart(false /*sortByApi*/);
-        assertFalse(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertFalse(m.updateSourcePackages(op2, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2),
         }));
-        assertTrue(m.updateEnd(op2));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_InstallPackage() {
 
         // First load reveals a new package
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
-        UpdateOp op1 = m.updateStart(false /*sortByApi*/);
+        m.updateStart();
         // no local package
-        assertFalse(m.updateSourcePackages(op1, null /*locals*/, new Package[0]));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[0]));
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateEnd(op1));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
 
         // Install it. The display only shows the installed one, 'hiding' the remote package
-        UpdateOp op2 = m.updateStart(false /*sortByApi*/);
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertFalse(m.updateSourcePackages(op2, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateEnd(op2));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // Now we have an update
-        UpdateOp op3 = m.updateStart(false /*sortByApi*/);
-        assertFalse(m.updateSourcePackages(op3, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateSourcePackages(op3, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 2),
         }));
-        assertTrue(m.updateEnd(op3));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1, updated by:MockEmptyPackage 'type1' rev=2>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_DeletePackage() {
         SdkSource src1 = new SdkRepoSource("http://repo.com/url", "repo1");
 
         // Start with an installed package and its matching remote package
-        UpdateOp op2 = m.updateStart(false /*sortByApi*/);
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        m.updateStart();
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertFalse(m.updateSourcePackages(op2, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateEnd(op2));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <INSTALLED, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // User now deletes the installed package.
-        UpdateOp op1 = m.updateStart(false /*sortByApi*/);
+        m.updateStart();
         // no local package
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[0]));
-        assertFalse(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[0]));
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockEmptyPackage(src1, "type1", 1),
         }));
-        assertTrue(m.updateEnd(op1));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=1>\n" +
                 "-- <NEW, pkg:MockEmptyPackage 'type1' rev=1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     public void testSortBySource_CompleteUpdate() {
@@ -644,20 +640,20 @@ public class PackagesDiffLogicTest extends TestCase {
         SdkSource src2 = new SdkRepoSource("http://repo.com/url2", "repo2");
 
         // First update has the typical tools and a couple extras
-        UpdateOp op1 = m.updateStart(false /*sortByApi*/);
+        m.updateStart();
 
-        assertTrue(m.updateSourcePackages(op1, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
         }));
-        assertTrue(m.updateSourcePackages(op1, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
                 new MockExtraPackage(src1, "android", "usb_driver", 5, 3),
         }));
-        assertTrue(m.updateEnd(op1));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=4>\n" +
@@ -665,14 +661,14 @@ public class PackagesDiffLogicTest extends TestCase {
                 "-- <INSTALLED, pkg:Android SDK Platform-tools, revision 3>\n" +
                 "-- <INSTALLED, pkg:Android USB Driver package, revision 4, updated by:Android USB Driver package, revision 5>\n" +
                 "-- <NEW, pkg:Carrier Custom Rom package, revision 1>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // Next update adds platforms and addon, sorted in a category based on their API level
-        UpdateOp op2 = m.updateStart(false /*sortByApi*/);
+        m.updateStart();
         MockPlatformPackage p1;
         MockPlatformPackage p2;
 
-        assertTrue(m.updateSourcePackages(op2, null /*locals*/, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
@@ -681,7 +677,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockPlatformPackage(src1, 3, 6, 3),       // API 3
                 new MockAddonPackage(src2, "addon A", p1, 5),
         }));
-        assertTrue(m.updateSourcePackages(op2, src1, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
@@ -689,7 +685,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 // second update
                 p2 = new MockPlatformPackage(src1, 2, 4, 3),    // API 2
         }));
-        assertTrue(m.updateSourcePackages(op2, src2, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src2, new Package[] {
                 new MockAddonPackage(src2, "addon C", p2, 9),
                 new MockAddonPackage(src2, "addon A", p1, 6),
                 new MockAddonPackage(src2, "addon B", p2, 7),
@@ -697,7 +693,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockAddonPackage(src2, "addon B", p2, 8),
                 new MockAddonPackage(src2, "addon B", p2, 9),
         }));
-        assertTrue(m.updateEnd(op2));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=7>\n" +
@@ -712,13 +708,13 @@ public class PackagesDiffLogicTest extends TestCase {
                 "-- <NEW, pkg:addon B by vendor 2, Android API 2, revision 7, updated by:addon B by vendor 2, Android API 2, revision 9>\n" +
                 "-- <NEW, pkg:addon C by vendor 2, Android API 2, revision 9>\n" +
                 "-- <INSTALLED, pkg:addon A by vendor 1, Android API 1, revision 5, updated by:addon A by vendor 1, Android API 1, revision 6>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
 
         // Reloading the same thing should have no impact except for the update methods
         // returning false when they don't change the current list.
-        UpdateOp op3 = m.updateStart(false /*sortByApi*/);
+        m.updateStart();
 
-        assertFalse(m.updateSourcePackages(op3, null /*locals*/, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, null /*locals*/, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "android", "usb_driver", 4, 3),
@@ -727,7 +723,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockPlatformPackage(src1, 3, 6, 3),
                 new MockAddonPackage(src2, "addon A", p1, 5),
         }));
-        assertFalse(m.updateSourcePackages(op3, src1, new Package[] {
+        assertFalse(m.updateSourcePackages(false /*sortByApi*/, src1, new Package[] {
                 new MockToolPackage(src1, 10, 3),
                 new MockPlatformToolPackage(src1, 3),
                 new MockExtraPackage(src1, "carrier", "custom_rom", 1, 0),
@@ -735,7 +731,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 // second update
                 p2 = new MockPlatformPackage(src1, 2, 4, 3),
         }));
-        assertTrue(m.updateSourcePackages(op3, src2, new Package[] {
+        assertTrue(m.updateSourcePackages(false /*sortByApi*/, src2, new Package[] {
                 new MockAddonPackage(src2, "addon C", p2, 9),
                 new MockAddonPackage(src2, "addon A", p1, 6),
                 new MockAddonPackage(src2, "addon B", p2, 7),
@@ -745,7 +741,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 new MockAddonPackage(src2, "addon B", p2, 8),
                 new MockAddonPackage(src2, "addon B", p2, 9),
         }));
-        assertTrue(m.updateEnd(op3));
+        assertTrue(m.updateEnd(false /*sortByApi*/));
 
         assertEquals(
                 "PkgSourceCategory <source=repo1 (repo.com), #items=7>\n" +
@@ -760,7 +756,7 @@ public class PackagesDiffLogicTest extends TestCase {
                 "-- <NEW, pkg:addon B by vendor 2, Android API 2, revision 7, updated by:addon B by vendor 2, Android API 2, revision 9>\n" +
                 "-- <NEW, pkg:addon C by vendor 2, Android API 2, revision 9>\n" +
                 "-- <INSTALLED, pkg:addon A by vendor 1, Android API 1, revision 5, updated by:addon A by vendor 1, Android API 1, revision 6>\n",
-               getTree(m));
+                getTree(m, false /*displaySortByApi*/));
     }
 
     // ----
@@ -774,10 +770,10 @@ public class PackagesDiffLogicTest extends TestCase {
      *   -- &lt;PkgItem description&gt;
      * </pre>
      */
-    public String getTree(PackagesDiffLogic l) {
+    public String getTree(PackagesDiffLogic l, boolean displaySortByApi) {
         StringBuilder sb = new StringBuilder();
 
-        for (PkgCategory cat : l.mCurrentCategories) {
+        for (PkgCategory cat : m.getCategories(displaySortByApi)) {
             sb.append(cat.toString()).append('\n');
             for (PkgItem item : cat.getItems()) {
                 sb.append("-- ").append(item.toString()).append('\n');