Upstream accessibility font size preferences.

Moves ForceEnableZoom, UserSetForceEnableZoom, and 
FontScaleFactor preferences upstream and adds support for
observing all those preferences in Java.

UserSetForceEnableZoom is currently stored using Android
SharedPreferences, which are application global, so this
class is currently not keyed off the profile. Preferably
this should be migrated to be per profile, at which point
the FontSizePrefs could be keyed off the profile instead of
being an application global singleton.

BUG=383630

Review URL: https://codereview.chromium.org/415343002

Cr-Commit-Position: refs/heads/master@{#289185}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289185 0039d316-1c4b-4281-b951-d872f2087c98

chrome/android/java/src/org/chromium/chrome/browser/accessibility/FontSizePrefs.java

+// Copyright 2014 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.accessibility;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.preference.PreferenceManager;
+
+import org.chromium.base.CalledByNative;
+import org.chromium.base.NativeCall;
+import org.chromium.base.ThreadUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Singleton wrapper class for native FontSizePrefs. Provides support for preferences for Font
+ * Scale Factor, Force Enable Zoom, and User Set Force Enable Zoom. User Set Force Enable Zoom
+ * tracks whether the user  has manually set the force enable zoom button, while Force Enable Zoom
+ * tracks whether force enable zoom is on or off. Font Scale Factor reflects the global font scale.
+ */
+public class FontSizePrefs implements OnSharedPreferenceChangeListener {
+    public static final String PREF_FORCE_ENABLE_ZOOM = "force_enable_zoom";
+    public static final String PREF_TEXT_SCALE = "text_scale";
+    public static final String PREF_USER_SET_FORCE_ENABLE_ZOOM = "user_set_force_enable_zoom";
+
+    private static FontSizePrefs mFontSizePrefs;
+    private final long mFontSizePrefsAndroidPtr;
+    private final SharedPreferences mSharedPreferences;
+    private final Map<Observer, FontSizePrefsObserverWrapper> mObserverMap;
+
+    /**
+     * Observer interface for observing changes in FontScaleFactor, ForceEnableZoom and
+     * UserSetForceEnableZoom.
+     */
+    public interface Observer {
+        void onChangeFontSize(float newFontSize);
+        void onChangeForceEnableZoom(boolean enabled);
+        void onChangeUserSetForceEnableZoom(boolean enabled);
+    }
+
+    /**
+     * Wrapper for FontSizePrefsObserverAndroid.
+     */
+    private static class FontSizePrefsObserverWrapper {
+        private final Observer mFontSizePrefsObserver;
+        private final long mNativeFontSizePrefsObserverWrapperPtr;
+
+        public FontSizePrefsObserverWrapper(Observer observer) {
+            mNativeFontSizePrefsObserverWrapperPtr = nativeInitObserverAndroid();
+            mFontSizePrefsObserver = observer;
+        }
+
+        public long getNativePtr() {
+            return mNativeFontSizePrefsObserverWrapperPtr;
+        }
+
+        public void destroy() {
+            nativeDestroyObserverAndroid(mNativeFontSizePrefsObserverWrapperPtr);
+        }
+
+        @CalledByNative("FontSizePrefsObserverWrapper")
+        public void onChangeFontSize(float newFontSize) {
+            mFontSizePrefsObserver.onChangeFontSize(newFontSize);
+        }
+
+        @CalledByNative("FontSizePrefsObserverWrapper")
+        public void onChangeForceEnableZoom(boolean enabled) {
+            mFontSizePrefsObserver.onChangeForceEnableZoom(enabled);
+        }
+
+        public void onChangeUserSetForceEnableZoom(boolean enabled) {
+            mFontSizePrefsObserver.onChangeUserSetForceEnableZoom(enabled);
+        }
+
+        @NativeCall("FontSizePrefsObserverWrapper")
+        private native long nativeInitObserverAndroid();
+
+        @NativeCall("FontSizePrefsObserverWrapper")
+        private native void nativeDestroyObserverAndroid(long nativeFontSizePrefsObserverAndroid);
+    }
+
+    private FontSizePrefs(Context context) {
+        mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+        mSharedPreferences.registerOnSharedPreferenceChangeListener(this);
+        mFontSizePrefsAndroidPtr = nativeInit();
+        mObserverMap = new HashMap<Observer, FontSizePrefsObserverWrapper>();
+    }
+
+    /**
+     * Returns the FontSizePrefs corresponding to the inputted Profile. If no FontSizePrefs existed,
+     * this method will create one.
+     */
+    public static FontSizePrefs getInstance(Context context) {
+        ThreadUtils.assertOnUiThread();
+        if (mFontSizePrefs == null) {
+            mFontSizePrefs = new FontSizePrefs(context);
+        }
+        return mFontSizePrefs;
+    }
+
+    /**
+     * Adds the observer to listen for Font Scale and Force Enable Zoom preferences.
+     * @return true if the observerMap was changed as a result of the call.
+     */
+    public boolean addObserver(Observer obs) {
+        if (mObserverMap.containsKey(obs)) return false;
+        FontSizePrefsObserverWrapper wrappedObserver =
+                new FontSizePrefsObserverWrapper(obs);
+        nativeAddObserver(mFontSizePrefsAndroidPtr, wrappedObserver.getNativePtr());
+        mObserverMap.put(obs, wrappedObserver);
+        return true;
+    }
+
+    /**
+     * Removes the observer and unregisters it from Font Scale and Force Enable Zoom changes.
+     * @return true if an observer was removed as a result of the call.
+     */
+    public boolean removeObserver(Observer obs) {
+        FontSizePrefsObserverWrapper wrappedObserver = mObserverMap.remove(obs);
+        if (wrappedObserver == null) return false;
+        nativeRemoveObserver(mFontSizePrefsAndroidPtr, wrappedObserver.getNativePtr());
+        wrappedObserver.destroy();
+        return true;
+    }
+
+    /**
+     * Sets UserSetForceEnableZoom. This is the only one of three preferences stored through
+     * SharedPreferences.
+     */
+    public void setUserSetForceEnableZoom(boolean enabled) {
+        SharedPreferences.Editor sharedPreferencesEditor = mSharedPreferences.edit();
+        sharedPreferencesEditor.putBoolean(PREF_USER_SET_FORCE_ENABLE_ZOOM, enabled);
+        sharedPreferencesEditor.apply();
+    }
+
+    /**
+     * Returns true if user has manually set ForceEnableZoom and false otherwise.
+     */
+    public boolean getUserSetForceEnableZoom() {
+        return mSharedPreferences.getBoolean(PREF_USER_SET_FORCE_ENABLE_ZOOM,
+                false);
+    }
+
+    public void setFontScaleFactor(float fontScaleFactor) {
+        nativeSetFontScaleFactor(mFontSizePrefsAndroidPtr, fontScaleFactor);
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        if (PREF_USER_SET_FORCE_ENABLE_ZOOM.equals(key)) {
+            for (FontSizePrefsObserverWrapper obsWrapper : mObserverMap.values()) {
+                obsWrapper.onChangeUserSetForceEnableZoom(getUserSetForceEnableZoom());
+            }
+        }
+    }
+
+    public float getFontScaleFactor() {
+        return nativeGetFontScaleFactor(mFontSizePrefsAndroidPtr);
+    }
+
+    public void setForceEnableZoom(boolean enabled) {
+        nativeSetForceEnableZoom(mFontSizePrefsAndroidPtr, enabled);
+    }
+
+    public boolean getForceEnableZoom() {
+        return nativeGetForceEnableZoom(mFontSizePrefsAndroidPtr);
+    }
+
+    public void destroy() {
+        mSharedPreferences.unregisterOnSharedPreferenceChangeListener(this);
+        nativeDestroy(mFontSizePrefsAndroidPtr);
+    }
+
+    private native void nativeAddObserver(long nativeFontSizePrefsAndroid,
+            long nativeObserverPtr);
+
+    private native void nativeRemoveObserver(long nativeFontSizePrefsAndroid,
+            long nativeObserverPtr);
+
+    private native long nativeInit();
+
+    private native void nativeDestroy(long nativeFontSizePrefsAndroid);
+
+    private native void nativeSetFontScaleFactor(long nativeFontSizePrefsAndroid, float font);
+
+    private native float nativeGetFontScaleFactor(long nativeFontSizePrefsAndroid);
+
+    private native boolean nativeGetForceEnableZoom(long nativeFontSizePrefsAndroid);
+
+    private native void nativeSetForceEnableZoom(long nativeFontSizePrefsAndroid, boolean enabled);
+}

chrome/android/javatests/src/org/chromium/chrome/browser/accessibility/FontSizePrefsTest.java

+// Copyright 2014 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.accessibility;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.test.util.Feature;
+import org.chromium.base.ThreadUtils;
+import org.chromium.chrome.shell.ChromeShellTestBase;
+import org.chromium.content.browser.test.util.UiUtils;
+
+import java.util.concurrent.Callable;
+
+/**
+ * Test class for {@link FontSizePrefs}.
+ */
+public class FontSizePrefsTest extends ChromeShellTestBase {
+
+    private FontSizePrefs mFontSizePrefs;
+    private SharedPreferences.Editor mSharedPreferencesEditor;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        Context context = getInstrumentation().getTargetContext();
+        startChromeBrowserProcessSync(context);
+        getFontSizePrefs(context);
+        mSharedPreferencesEditor = PreferenceManager.getDefaultSharedPreferences(context).edit();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mSharedPreferencesEditor.remove(FontSizePrefs.PREF_USER_SET_FORCE_ENABLE_ZOOM).commit();
+        super.tearDown();
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testGetAndSetFontAndForceEnableZoom() throws InterruptedException {
+        // Check default font.
+        assertEquals(1f, getFontScale());
+        // Check that setting the value of font scale factor works.
+        float newTextScale = 1.2f;
+        setFontScale(newTextScale);
+        assertEquals(newTextScale, getFontScale());
+
+        // Check the default value of force enable zoom.
+        assertFalse(getForceEnableZoom());
+        // Check that setting the value of force enable zoom works.
+        setForceEnableZoom(true);
+        assertTrue(getForceEnableZoom());
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testGetAndSetUserSetForceEnableZoom() throws InterruptedException {
+        // Check the default value of user set force enable zoom.
+        assertFalse(mFontSizePrefs.getUserSetForceEnableZoom());
+        // Check that setting the value of user set force enable zoom works.
+        setUserSetForceEnableZoom(true);
+        assertTrue(mFontSizePrefs.getUserSetForceEnableZoom());
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testObserversForceEnableZoom() throws InterruptedException {
+        TestingObserver test1 = new TestingObserver();
+        TestingObserver test2 = new TestingObserver();
+        mFontSizePrefs.addObserver(test1);
+        mFontSizePrefs.addObserver(test2);
+
+        // Checks that force enable zoom for both observers is correctly changed.
+        setForceEnableZoom(true);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertTrue(test1.getForceEnableZoom());
+        assertTrue(test2.getForceEnableZoom());
+
+        // Checks that removing observer and setting force enable zoom works.
+        mFontSizePrefs.removeObserver(test1);
+        setForceEnableZoom(false);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertTrue(test1.getForceEnableZoom());
+        assertFalse(test2.getForceEnableZoom());
+        mFontSizePrefs.removeObserver(test2);
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testObserversFontScale() throws InterruptedException {
+        TestingObserver test1 = new TestingObserver();
+        TestingObserver test2 = new TestingObserver();
+        mFontSizePrefs.addObserver(test1);
+        mFontSizePrefs.addObserver(test2);
+
+        // Checks that font scale for both observers is correctly changed.
+        float newTextScale = 1.2f;
+        setFontScale(newTextScale);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertEquals(newTextScale, test1.getFontScaleFactor());
+        assertEquals(newTextScale, test2.getFontScaleFactor());
+
+        // Checks that removing observer and setting font works.
+        float newerTextScale = 1.4f;
+        mFontSizePrefs.removeObserver(test1);
+        setFontScale(newerTextScale);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertEquals(newTextScale, test1.getFontScaleFactor());
+        assertEquals(newerTextScale, test2.getFontScaleFactor());
+        mFontSizePrefs.removeObserver(test2);
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testObserversUserSetForceEnableZoom() throws InterruptedException {
+        TestingObserver test1 = new TestingObserver();
+        TestingObserver test2 = new TestingObserver();
+        mFontSizePrefs.addObserver(test1);
+        mFontSizePrefs.addObserver(test2);
+
+        // Checks that force enable zoom for both observers is correctly changed.
+        setUserSetForceEnableZoom(true);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertTrue(test1.getUserSetForceEnableZoom());
+        assertTrue(test2.getUserSetForceEnableZoom());
+
+        // Checks that removing observer and setting force enable zoom works.
+        mFontSizePrefs.removeObserver(test1);
+        setUserSetForceEnableZoom(false);
+        UiUtils.settleDownUI(getInstrumentation());
+        assertTrue(test1.getUserSetForceEnableZoom());
+        assertFalse(test2.getUserSetForceEnableZoom());
+        mFontSizePrefs.removeObserver(test2);
+    }
+
+    @SmallTest
+    @Feature({"Accessibility"})
+    public void testMultipleAddMultipleDeleteObservers() throws InterruptedException {
+        TestingObserver test = new TestingObserver();
+
+        // Should successfully add the observer the first time.
+        assertTrue(mFontSizePrefs.addObserver(test));
+        // Observer cannot be added again, should return false.
+        assertFalse(mFontSizePrefs.addObserver(test));
+
+        // Delete the observer the first time.
+        assertTrue(mFontSizePrefs.removeObserver(test));
+        // Observer cannot be deleted again, should return false.
+        assertFalse(mFontSizePrefs.removeObserver(test));
+    }
+
+    private static class TestingObserver implements FontSizePrefs.Observer {
+        private float mFontSize;
+        private boolean mForceEnableZoom;
+        private boolean mUserSetForceEnableZoom;
+
+        public TestingObserver() {
+            mFontSize = 1;
+            mForceEnableZoom = false;
+            mUserSetForceEnableZoom = false;
+        }
+
+        public float getFontScaleFactor() {
+            return mFontSize;
+        }
+
+        public void onChangeFontSize(float font) {
+            mFontSize = font;
+        }
+
+        public boolean getForceEnableZoom() {
+            return mForceEnableZoom;
+        }
+
+        public void onChangeForceEnableZoom(boolean enabled) {
+            mForceEnableZoom = enabled;
+        }
+
+        public void onChangeUserSetForceEnableZoom(boolean enabled) {
+            mUserSetForceEnableZoom = enabled;
+        }
+
+        public boolean getUserSetForceEnableZoom() {
+            return mUserSetForceEnableZoom;
+        }
+    }
+
+    private void getFontSizePrefs(final Context context) {
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            public void run() {
+                mFontSizePrefs = FontSizePrefs.getInstance(context);
+            }
+        });
+    }
+
+    private void setFontScale(final float fontsize) {
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            public void run() {
+                mFontSizePrefs.setFontScaleFactor(fontsize);
+            }
+        });
+    }
+
+    private float getFontScale() {
+        return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Float>() {
+            @Override
+            public Float call() {
+                return mFontSizePrefs.getFontScaleFactor();
+            }
+        });
+    }
+
+    private void setForceEnableZoom(final boolean enabled) {
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            public void run() {
+                mFontSizePrefs.setForceEnableZoom(enabled);
+            }
+        });
+    }
+
+    private boolean getForceEnableZoom() {
+        return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
+            @Override
+            public Boolean call() {
+                return mFontSizePrefs.getForceEnableZoom();
+            }
+        });
+    }
+
+    private void setUserSetForceEnableZoom(final boolean enabled) {
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            public void run() {
+                mFontSizePrefs.setUserSetForceEnableZoom(enabled);
+            }
+        });
+    }
+}

chrome/browser/android/accessibility/font_size_prefs_android.cc

+// Copyright 2014 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.
+
+#include "chrome/browser/android/accessibility/font_size_prefs_android.h"
+
+#include "base/observer_list.h"
+#include "base/prefs/pref_change_registrar.h"
+#include "base/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile_android.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/pref_names.h"
+#include "jni/FontSizePrefs_jni.h"
+
+FontSizePrefsAndroid::FontSizePrefsAndroid(JNIEnv* env, jobject obj)
+    : pref_service_(ProfileManager::GetActiveUserProfile()->GetPrefs()) {
+  java_ref_.Reset(env, obj);
+  pref_change_registrar_.reset(new PrefChangeRegistrar);
+  pref_change_registrar_->Init(pref_service_);
+  pref_change_registrar_->Add(
+      prefs::kWebKitFontScaleFactor,
+      base::Bind(&FontSizePrefsAndroid::OnFontScaleFactorPrefsChanged,
+                 base::Unretained(this)));
+  pref_change_registrar_->Add(
+      prefs::kWebKitForceEnableZoom,
+      base::Bind(&FontSizePrefsAndroid::OnForceEnableZoomPrefsChanged,
+                 base::Unretained(this)));
+}
+
+FontSizePrefsAndroid::~FontSizePrefsAndroid() {
+}
+
+void FontSizePrefsAndroid::Destroy(JNIEnv* env, jobject obj) {
+  delete this;
+}
+
+void FontSizePrefsAndroid::SetFontScaleFactor(JNIEnv* env,
+                                              jobject obj,
+                                              jfloat font_size) {
+  pref_service_->SetDouble(prefs::kWebKitFontScaleFactor,
+                           static_cast<double>(font_size));
+}
+
+float FontSizePrefsAndroid::GetFontScaleFactor(JNIEnv* env, jobject obj) {
+  return pref_service_->GetDouble(prefs::kWebKitFontScaleFactor);
+}
+
+void FontSizePrefsAndroid::SetForceEnableZoom(JNIEnv* env,
+                                              jobject obj,
+                                              jboolean enabled) {
+  pref_service_->SetBoolean(prefs::kWebKitForceEnableZoom, enabled);
+}
+
+bool FontSizePrefsAndroid::GetForceEnableZoom(JNIEnv* env, jobject obj) {
+  return pref_service_->GetBoolean(prefs::kWebKitForceEnableZoom);
+}
+
+void FontSizePrefsAndroid::AddObserver(JNIEnv* env,
+                                       jobject obj,
+                                       jlong observer_ptr) {
+  FontSizePrefsObserverAndroid* font_size_prefs_observer_android =
+      reinterpret_cast<FontSizePrefsObserverAndroid*>(observer_ptr);
+  observers_.AddObserver(font_size_prefs_observer_android);
+}
+
+void FontSizePrefsAndroid::RemoveObserver(JNIEnv* env,
+                                          jobject obj,
+                                          jlong observer_ptr) {
+  FontSizePrefsObserverAndroid* font_size_prefs_observer_android =
+      reinterpret_cast<FontSizePrefsObserverAndroid*>(observer_ptr);
+  observers_.RemoveObserver(font_size_prefs_observer_android);
+}
+
+bool FontSizePrefsAndroid::Register(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+jlong Init(JNIEnv* env, jobject obj) {
+  FontSizePrefsAndroid* font_size_prefs_android =
+      new FontSizePrefsAndroid(env, obj);
+  return reinterpret_cast<intptr_t>(font_size_prefs_android);
+}
+
+void FontSizePrefsAndroid::OnFontScaleFactorPrefsChanged() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  FOR_EACH_OBSERVER(Observer,
+                    observers_,
+                    OnChangeFontSize(GetFontScaleFactor(env, java_ref_.obj())));
+}
+
+void FontSizePrefsAndroid::OnForceEnableZoomPrefsChanged() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  FOR_EACH_OBSERVER(
+      Observer,
+      observers_,
+      OnChangeForceEnableZoom(GetForceEnableZoom(env, java_ref_.obj())));
+}
+
+FontSizePrefsObserverAndroid::FontSizePrefsObserverAndroid(JNIEnv* env,
+                                                           jobject obj) {
+  java_ref_.Reset(env, obj);
+}
+
+FontSizePrefsObserverAndroid::~FontSizePrefsObserverAndroid() {
+}
+
+bool FontSizePrefsObserverAndroid::Register(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+void FontSizePrefsObserverAndroid::DestroyObserverAndroid(JNIEnv* env,
+                                                          jobject obj) {
+  delete this;
+}
+
+jlong InitObserverAndroid(JNIEnv* env, jobject obj) {
+  FontSizePrefsObserverAndroid* observer_wrapper =
+      new FontSizePrefsObserverAndroid(env, obj);
+  return reinterpret_cast<intptr_t>(observer_wrapper);
+}
+
+void FontSizePrefsObserverAndroid::OnChangeFontSize(float font_size) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_FontSizePrefsObserverWrapper_onChangeFontSize(
+      env, java_ref_.obj(), font_size);
+}
+
+void FontSizePrefsObserverAndroid::OnChangeForceEnableZoom(bool enabled) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_FontSizePrefsObserverWrapper_onChangeForceEnableZoom(
+      env, java_ref_.obj(), enabled);
+}

chrome/browser/android/accessibility/font_size_prefs_android.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_ANDROID_ACCESSIBILITY_FONT_SIZE_PREFS_ANDROID_H_
+#define CHROME_BROWSER_ANDROID_ACCESSIBILITY_FONT_SIZE_PREFS_ANDROID_H_
+
+#include <jni.h>
+#include "base/android/scoped_java_ref.h"
+#include "base/observer_list.h"
+
+class PrefChangeRegistrar;
+class PrefService;
+
+/*
+ * Native implementation of FontSizePrefs. This class is used to get and set
+ * FontScaleFactor and ForceEnableZoom.
+ */
+class FontSizePrefsAndroid {
+ public:
+  class Observer {
+   public:
+    virtual void OnChangeFontSize(float font) = 0;
+    virtual void OnChangeForceEnableZoom(bool enabled) = 0;
+  };
+
+  FontSizePrefsAndroid(JNIEnv* env, jobject obj);
+  ~FontSizePrefsAndroid();
+  void Destroy(JNIEnv* env, jobject obj);
+
+  void SetFontScaleFactor(JNIEnv* env, jobject obj, jfloat font);
+  float GetFontScaleFactor(JNIEnv* env, jobject obj);
+  void SetForceEnableZoom(JNIEnv* env, jobject obj, jboolean enabled);
+  bool GetForceEnableZoom(JNIEnv* env, jobject obj);
+
+  void AddObserver(JNIEnv* env, jobject obj, jlong obs);
+  void RemoveObserver(JNIEnv* env, jobject obj, jlong obs);
+
+  static bool Register(JNIEnv* env);
+
+ private:
+  // Callback for FontScaleFactor changes from pref change registrar.
+  void OnFontScaleFactorPrefsChanged();
+  // Callback for ForceEnableZoom changes from pref change registrar.
+  void OnForceEnableZoomPrefsChanged();
+
+  scoped_ptr<PrefChangeRegistrar> pref_change_registrar_;
+  PrefService* const pref_service_;
+  ObserverList<Observer> observers_;
+  base::android::ScopedJavaGlobalRef<jobject> java_ref_;
+
+  DISALLOW_COPY_AND_ASSIGN(FontSizePrefsAndroid);
+};
+
+/*
+ * Native implementation of FontSizePrefsObserverWrapper. Adds observer support
+ * for FontSizePrefs.
+ */
+class FontSizePrefsObserverAndroid : public FontSizePrefsAndroid::Observer {
+ public:
+  FontSizePrefsObserverAndroid(JNIEnv* env, jobject obj);
+  virtual ~FontSizePrefsObserverAndroid();
+  void DestroyObserverAndroid(JNIEnv* env, jobject obj);
+
+  static bool Register(JNIEnv* env);
+
+  // FontSizePrefs::Observer implementation.
+  virtual void OnChangeFontSize(float font) OVERRIDE;
+  virtual void OnChangeForceEnableZoom(bool enabled) OVERRIDE;
+
+ private:
+  base::android::ScopedJavaGlobalRef<jobject> java_ref_;
+};
+
+#endif  // CHROME_BROWSER_ANDROID_ACCESSIBILITY_FONT_SIZE_PREFS_ANDROID_H_

chrome/browser/android/chrome_jni_registrar.cc

@@ -7,6 +7,7 @@
 #include "base/android/jni_android.h"
 #include "base/android/jni_registrar.h"
 #include "base/debug/trace_event.h"
+#include "chrome/browser/android/accessibility/font_size_prefs_android.h"
 #include "chrome/browser/android/accessibility_util.h"
 #include "chrome/browser/android/banners/app_banner_manager.h"
 #include "chrome/browser/android/bookmarks/bookmarks_bridge.h"
@@ -140,6 +141,7 @@ static base::android::RegistrationMethod kChromeRegisteredMethods[] = {
       RegisterExternalPrerenderHandlerAndroid },
   { "FaviconHelper", FaviconHelper::RegisterFaviconHelper },
   { "FeedbackReporter", dom_distiller::android::RegisterFeedbackReporter },
+  { "FontSizePrefsAndroid", FontSizePrefsAndroid::Register },
   { "ForeignSessionHelper",
     ForeignSessionHelper::RegisterForeignSessionHelper },
   { "InfoBarContainer", RegisterInfoBarContainer },

chrome/chrome_browser.gypi

@@ -12,7 +12,8 @@
     'chrome_browser_non_ios_sources': [
       'browser/about_flags.cc',
       'browser/about_flags.h',
-      'browser/android/accessibility_util.cc',
+      'browser/android/accessibility/font_size_prefs_android.cc',
+      'browser/android/accessibility/font_size_prefs_android.h',      'browser/android/accessibility_util.cc',
       'browser/android/accessibility_util.h',
       'browser/android/activity_type_id_list.h',
       'browser/android/activity_type_ids.cc',
@@ -2760,6 +2761,7 @@
     'chrome_browser_jni_sources': [
       'android/java/src/org/chromium/chrome/browser/AccessibilityUtil.java',
       'android/java/src/org/chromium/chrome/browser/ApplicationLifetime.java',
+      'android/java/src/org/chromium/chrome/browser/accessibility/FontSizePrefs.java',
       'android/java/src/org/chromium/chrome/browser/autofill/AutofillDialogControllerAndroid.java',
       'android/java/src/org/chromium/chrome/browser/autofill/AutofillDialogResult.java',
       'android/java/src/org/chromium/chrome/browser/autofill/AutofillLogger.java',