Add RecentTabsPageTest

chrome/android/java/src/org/chromium/chrome/browser/ntp/FakeRecentlyClosedTabManager.java

+// Copyright 2017 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;
+
+import org.chromium.chrome.browser.tab.Tab;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A fake implementation of {@link RecentlyClosedTabManager} for testing purposes.
+ */
+public class FakeRecentlyClosedTabManager implements RecentlyClosedTabManager {
+    private RecentlyClosedCallback mCallback;
+    private List<RecentlyClosedTab> mTabs = new ArrayList<>();
+
+    @Override
+    public void setRecentlyClosedCallback(RecentlyClosedCallback callback) {
+        mCallback = callback;
+    }
+
+    @Override
+    public List<RecentlyClosedTab> getRecentlyClosedTabs(int maxTabCount) {
+        List<RecentlyClosedTab> tabs = new ArrayList<>();
+        for (int i = 0; i < maxTabCount && i < mTabs.size(); i++) {
+            tabs.add(mTabs.get(i));
+        }
+        return tabs;

[Bernhard Bauer, 2017/01/04 11:54:16]

Could you do `mTabs.subList(0, Math.min(maxTabCount, mTabs.size()))`?

[Michael van Ouwerkerk, 2017/01/05 11:02:14]

Perhaps, but: "The returned List is backed by this List so changes to it are
reflected by the other."

That's not the way the real implementation works, and seems like it could lead
to tricky bugs.

[Bernhard Bauer, 2017/01/05 17:47:37]

I'm okay with the code as it is, but that does bring up a point... Are you
referring to the case where a caller modifies the returned list (thereby
mutating the underlying list), or the case where the underlying list is mutated?
Maybe we should be more explicit in the contract of this class about which (if
any) of these operations may happen.

[Michael van Ouwerkerk, 2017/01/06 11:11:11]

From the subList docs:
https://docs.oracle.com/javase/8/docs/api/java/util/List.html#subList-int-int-
"The returned list is backed by this list, so non-structural changes in the
returned list are reflected in this list, and vice-versa."

Generally for most such cases, I think we should use something like the Guava
ImmutableList, but we don't use Guava. We could use Collections.unmodifiableList
here to wrap the new list, but that wouldn't change the return type and not
achieve much as it's already a new list.

So, just a minor documentation addition that this is a snapshot.

+    }
+
+    @Override
+    public boolean openRecentlyClosedTab(
+            Tab tab, RecentlyClosedTab recentTab, int windowOpenDisposition) {
+        return false;
+    }
+
+    @Override
+    public void openRecentlyClosedTab() {}
+
+    @Override
+    public void clearRecentlyClosedTabs() {
+        mTabs.clear();
+        if (mCallback != null) mCallback.onUpdated();
+    }
+
+    public void setRecentlyClosedTabs(List<RecentlyClosedTab> tabs) {
+        mTabs = new ArrayList<>(tabs);
+        if (mCallback != null) mCallback.onUpdated();
+    }
+}