[sync] Add java InvalidationController for Android.

* Adds InvalidationController to facilitate the move to the new
  invalidation client, but still supporting the old way.
* Sets up the chromium test shell to be able to run the new tests for
  sync.
* Upstreaming a few base test utilities for MockContext and
  SharedPreferences.

InvalidationController and InvalidationControllerTest provided by
dsmyers@chromium.org.

BUG=159221


Review URL: https://chromiumcodereview.appspot.com/11778084

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@176533 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 290 insertions, 0 deletions

diff --git a/base/test/android/javatests/src/org/chromium/base/test/util/AdvancedMockContext.java b/base/test/android/javatests/src/org/chromium/base/test/util/AdvancedMockContext.java
new file mode 100644
index 0000000..a57a8b0
--- /dev/null
+++ b/base/test/android/javatests/src/org/chromium/base/test/util/AdvancedMockContext.java
@@ -0,0 +1,103 @@
+// Copyright (c) 2013 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.base.test.util;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.SharedPreferences;
+import android.test.mock.MockContentResolver;
+import android.test.mock.MockContext;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * ContextWrapper that adds functionality for SharedPreferences and a way to set and retrieve flags.
+ */
+public class AdvancedMockContext extends ContextWrapper {
+
+    private final MockContentResolver mMockContentResolver = new MockContentResolver();
+
+    private final Map<String, SharedPreferences> mSharedPreferences =
+            new HashMap<String, SharedPreferences>();
+
+    private final Map<String, Boolean> flags = new HashMap<String, Boolean>();
+
+    public AdvancedMockContext(Context base) {
+        super(base);
+    }
+
+    public AdvancedMockContext() {
+        super(new MockContext());
+    }
+
+    @Override
+    public String getPackageName() {
+        return getBaseContext().getPackageName();
+    }
+
+    @Override
+    public Context getApplicationContext() {
+        return this;
+    }
+
+    @Override
+    public ContentResolver getContentResolver() {
+        return mMockContentResolver;
+    }
+
+    public MockContentResolver getMockContentResolver() {
+        return mMockContentResolver;
+    }
+
+    @Override
+    public SharedPreferences getSharedPreferences(String name, int mode) {
+        synchronized (mSharedPreferences) {
+            if (!mSharedPreferences.containsKey(name)) {
+                // Auto-create shared preferences to mimic Android Context behavior
+                mSharedPreferences.put(name, new InMemorySharedPreferences());
+            }
+            return mSharedPreferences.get(name);
+        }
+    }
+
+    public void addSharedPreferences(String name, Map<String, Object> data) {
+        synchronized (mSharedPreferences) {
+            mSharedPreferences.put(name, new InMemorySharedPreferences(data));
+        }
+    }
+
+    public void setFlag(String key) {
+        flags.put(key, true);
+    }
+
+    public void clearFlag(String key) {
+        flags.remove(key);
+    }
+
+    public boolean isFlagSet(String key) {
+        return flags.containsKey(key) && flags.get(key);
+    }
+
+    public static class MapBuilder {
+
+        private final Map<String, Object> mData = new HashMap<String, Object>();
+
+        public static MapBuilder create() {
+            return new MapBuilder();
+        }
+
+        public MapBuilder add(String key, Object value) {
+            mData.put(key, value);
+            return this;
+        }
+
+        public Map<String, Object> build() {
+            return mData;
+        }
+
+    }
+}
diff --git a/base/test/android/javatests/src/org/chromium/base/test/util/InMemorySharedPreferences.java b/base/test/android/javatests/src/org/chromium/base/test/util/InMemorySharedPreferences.java
new file mode 100644
index 0000000..e42562b
--- /dev/null
+++ b/base/test/android/javatests/src/org/chromium/base/test/util/InMemorySharedPreferences.java
@@ -0,0 +1,187 @@
+// Copyright (c) 2013 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.base.test.util;
+
+import android.content.SharedPreferences;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * An implementation of SharedPreferences that can be used in tests.
+ * <p/>
+ * It keeps all state in memory, and there is no difference between apply() and commit().
+ */
+public class InMemorySharedPreferences implements SharedPreferences {
+
+    private final Map<String, Object> mData;
+
+    private final SharedPreferences.Editor mEditor = new InMemoryEditor();
+
+    public InMemorySharedPreferences() {
+        mData = new HashMap<String, Object>();
+    }
+
+    public InMemorySharedPreferences(Map<String, Object> data) {
+        mData = data;
+    }
+
+    @Override
+    public Map<String, ?> getAll() {
+        return mData;
+    }
+
+    @Override
+    public String getString(String key, String defValue) {
+        if (mData.containsKey(key)) {
+            return (String) mData.get(key);
+        }
+        return defValue;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Set<String> getStringSet(String key, Set<String> defValues) {
+        if (mData.containsKey(key)) {
+            return (Set<String>) mData.get(key);
+        }
+        return defValues;
+    }
+
+    @Override
+    public int getInt(String key, int defValue) {
+        if (mData.containsKey(key)) {
+            return (Integer) mData.get(key);
+        }
+        return defValue;
+    }
+
+    @Override
+    public long getLong(String key, long defValue) {
+        if (mData.containsKey(key)) {
+            return (Long) mData.get(key);
+        }
+        return defValue;
+    }
+
+    @Override
+    public float getFloat(String key, float defValue) {
+        if (mData.containsKey(key)) {
+            return (Float) mData.get(key);
+        }
+        return defValue;
+    }
+
+    @Override
+    public boolean getBoolean(String key, boolean defValue) {
+        if (mData.containsKey(key)) {
+            return (Boolean) mData.get(key);
+        }
+        return defValue;
+    }
+
+    @Override
+    public boolean contains(String key) {
+        return mData.containsKey(key);
+    }
+
+    @Override
+    public SharedPreferences.Editor edit() {
+        return mEditor;
+    }
+
+    @Override
+    public void registerOnSharedPreferenceChangeListener(
+            SharedPreferences.OnSharedPreferenceChangeListener
+                    listener) {
+    }
+
+    @Override
+    public void unregisterOnSharedPreferenceChangeListener(
+            SharedPreferences.OnSharedPreferenceChangeListener listener) {
+    }
+
+    private class InMemoryEditor implements SharedPreferences.Editor {
+
+        private boolean mClearCalled;
+
+        private final Map<String, Object> mChanges = new HashMap<String, Object>();
+
+        @Override
+        public SharedPreferences.Editor putString(String key, String value) {
+            mChanges.put(key, value);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor putStringSet(String key, Set<String> values) {
+            mChanges.put(key, values);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor putInt(String key, int value) {
+            mChanges.put(key, value);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor putLong(String key, long value) {
+            mChanges.put(key, value);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor putFloat(String key, float value) {
+            mChanges.put(key, value);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor putBoolean(String key, boolean value) {
+            mChanges.put(key, value);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor remove(String key) {
+            // Magic value for removes
+            mChanges.put(key, this);
+            return this;
+        }
+
+        @Override
+        public SharedPreferences.Editor clear() {
+            mClearCalled = true;
+            return this;
+        }
+
+        @Override
+        public boolean commit() {
+            apply();
+            return true;
+        }
+
+        @Override
+        public void apply() {
+            if (mClearCalled) {
+                mData.clear();
+            }
+            for (Map.Entry<String, Object> entry : mChanges.entrySet()) {
+                String key = entry.getKey();
+                Object value = entry.getValue();
+                if (value == this) {
+                    // Special value for removal
+                    mData.remove(key);
+                } else {
+                    mData.put(key, value);
+                }
+            }
+        }
+
+    }
+
+}