Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-16 06:45:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Back out bug 707571 because of reftest failures

Browse Source
This commit is contained in:
Matt Brubeck 2012-05-18 09:31:27 -07:00
parent f33c539453
commit 2821ecfa99
8 changed files with 62 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
mobile/android/app/mobile.js
View File

@ -37,6 +37,21 @@
#filter substitution
// For browser.xml binding
//
// cacheRatio* is a ratio that determines the amount of pixels to cache. The
// ratio is multiplied by the viewport width or height to get the displayport's
// width or height, respectively.
//
// (divide integer value by 1000 to get the ratio)
//
// For instance: cachePercentageWidth is 1500
// viewport height is 500
// => display port height will be 500 * 1.5 = 750
//
pref("toolkit.browser.cacheRatioWidth", 2000);
pref("toolkit.browser.cacheRatioHeight", 3000);
// How long before a content view (a handle to a remote scrollable object)
// expires.
pref("toolkit.browser.contentViewExpire", 3000);
@ -49,6 +64,11 @@ pref("browser.tabs.remote", true);
pref("toolkit.screen.lock", false);
// From libpref/src/init/all.js, extended to allow a slightly wider zoom range.
pref("zoom.minPercent", 20);
pref("zoom.maxPercent", 400);
pref("toolkit.zoomManager.zoomValues", ".2,.3,.5,.67,.8,.9,1,1.1,1.2,1.33,1.5,1.7,2,2.4,3,4");
// Mobile will use faster, less durable mode.
pref("toolkit.storage.synchronous", 0);
@ -425,10 +445,20 @@ pref("dom.max_script_run_time", 20);
// JS error console
pref("devtools.errorconsole.enabled", false);
pref("browser.ui.layout.tablet", -1); // on: 1, off: 0, auto: -1
// kinetic tweakables
pref("browser.ui.kinetic.updateInterval", 16);
pref("browser.ui.kinetic.exponentialC", 1400);
pref("browser.ui.kinetic.polynomialC", 100);
pref("browser.ui.kinetic.swipeLength", 160);
pref("font.size.inflation.minTwips", 120);
// When true, zooming will be enabled on all sites, even ones that declare user-scalable=no.
pref("browser.ui.zoom.force-user-scalable", false);
// pinch gesture
pref("browser.ui.pinch.maxGrowth", 150); // max pinch distance growth
pref("browser.ui.pinch.maxShrink", 200); // max pinch distance shrinkage
pref("browser.ui.pinch.scalingFactor", 500); // scaling factor for above pinch limits
// Touch radius (area around the touch location to look for target elements),
// in 1/240-inch pixels:

22
mobile/android/base/GeckoApp.java
View File

@ -675,10 +675,6 @@ abstract public class GeckoApp
tab.updateFaviconURL(null);
tab.updateIdentityData(null);
tab.removeTransientDoorHangers();
tab.setAllowZoom(true);
tab.setDefaultZoom(0);
tab.setMinZoom(0);
tab.setMaxZoom(0);
tab.setHasTouchListeners(false);
tab.setCheckerboardColor(Color.WHITE);
@ -1005,23 +1001,6 @@ abstract public class GeckoApp
}
} else if (event.equals("Update:Restart")) {
doRestart("org.mozilla.gecko.restart_update");
} else if (event.equals("Tab:ViewportMetadata")) {
int tabId = message.getInt("tabID");
Tab tab = Tabs.getInstance().getTab(tabId);
if (tab == null)
return;
tab.setAllowZoom(message.getBoolean("allowZoom"));
tab.setDefaultZoom((float) message.getDouble("defaultZoom"));
tab.setMinZoom((float) message.getDouble("minZoom"));
tab.setMaxZoom((float) message.getDouble("maxZoom"));
// Sync up the LayerController and the tab if the tab's currently displayed.
LayerController controller = getLayerController();
if (controller != null && Tabs.getInstance().isSelectedTab(tab)) {
controller.setAllowZoom(tab.getAllowZoom());
controller.setDefaultZoom(tab.getDefaultZoom());
controller.setMinZoom(tab.getMinZoom());
controller.setMaxZoom(tab.getMaxZoom());
}
} else if (event.equals("Tab:HasTouchListener")) {
int tabId = message.getInt("tabID");
Tab tab = Tabs.getInstance().getTab(tabId);
@ -1741,7 +1720,6 @@ abstract public class GeckoApp
GeckoAppShell.registerGeckoEventListener("CharEncoding:State", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Update:Restart", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Tab:HasTouchListener", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Tab:ViewportMetadata", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Session:StatePurged", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Bookmark:Insert", GeckoApp.mAppContext);
GeckoAppShell.registerGeckoEventListener("Accessibility:Event", GeckoApp.mAppContext);

36
mobile/android/base/Tab.java
View File

@ -86,10 +86,6 @@ public final class Tab {
private String mDocumentURI;
private String mContentType;
private boolean mHasTouchListeners;
private boolean mAllowZoom;
private float mDefaultZoom;
private float mMinZoom;
private float mMaxZoom;
private ArrayList<View> mPluginViews;
private HashMap<Object, Layer> mPluginLayers;
private ContentResolver mContentResolver;
@ -288,38 +284,6 @@ public final class Tab {
return mState;
}
public void setAllowZoom(boolean aValue) {
mAllowZoom = aValue;
}
public boolean getAllowZoom() {
return mAllowZoom;
}
public void setDefaultZoom(float aValue) {
mDefaultZoom = aValue;
}
public float getDefaultZoom() {
return mDefaultZoom;
}
public void setMinZoom(float aValue) {
mMinZoom = aValue;
}
public float getMinZoom() {
return mMinZoom;
}
public void setMaxZoom(float aValue) {
mMaxZoom = aValue;
}
public float getMaxZoom() {
return mMaxZoom;
}
public void setHasTouchListeners(boolean aValue) {
mHasTouchListeners = aValue;
}

9
mobile/android/base/gfx/GeckoLayerClient.java
View File

@ -43,7 +43,6 @@ import org.mozilla.gecko.GeckoApp;
import org.mozilla.gecko.GeckoAppShell;
import org.mozilla.gecko.GeckoEvent;
import org.mozilla.gecko.GeckoEventResponder;
import org.mozilla.gecko.Tab;
import org.mozilla.gecko.Tabs;
import org.json.JSONArray;
import org.json.JSONException;
@ -60,6 +59,7 @@ import android.util.Log;
import android.view.View;
import java.util.Map;
import java.util.HashMap;
import org.mozilla.gecko.Tabs;
public class GeckoLayerClient implements GeckoEventResponder,
LayerView.Listener {
@ -350,12 +350,7 @@ public class GeckoLayerClient implements GeckoEventResponder,
}
});
mLayerController.setViewportMetrics(currentMetrics);
Tab tab = Tabs.getInstance().getSelectedTab();
mLayerController.setCheckerboardColor(tab.getCheckerboardColor());
mLayerController.setAllowZoom(tab.getAllowZoom());
mLayerController.setDefaultZoom(tab.getDefaultZoom());
mLayerController.setCheckerboardColor(Tabs.getInstance().getSelectedTab().getCheckerboardColor());
// At this point, we have just switched to displaying a different document than we
// we previously displaying. This means we need to abort any panning/zooming animations
// that are in progress and send an updated display port request to browser.js as soon

43
mobile/android/base/gfx/LayerController.java
View File

@ -41,6 +41,7 @@ package org.mozilla.gecko.gfx;
import org.mozilla.gecko.gfx.Layer;
import org.mozilla.gecko.ui.PanZoomController;
import org.mozilla.gecko.ui.SimpleScaleGestureDetector;
import org.mozilla.gecko.GeckoApp;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
@ -91,11 +92,6 @@ public class LayerController {
private int mCheckerboardColor = Color.WHITE;
private boolean mCheckerboardShouldShowChecks;
private boolean mAllowZoom;
private float mDefaultZoom;
private float mMinZoom;
private float mMaxZoom;
private boolean mForceRedraw;
public LayerController(Context context) {
@ -350,41 +346,4 @@ public class LayerController {
mCheckerboardColor = newColor;
mView.requestRender();
}
public void setAllowZoom(final boolean aValue) {
mAllowZoom = aValue;
mView.post(new Runnable() {
public void run() {
mView.getTouchEventHandler().setDoubleTapEnabled(aValue);
}
});
}
public boolean getAllowZoom() {
return mAllowZoom;
}
public void setDefaultZoom(float aValue) {
mDefaultZoom = aValue;
}
public float getDefaultZoom() {
return mDefaultZoom;
}
public void setMinZoom(float aValue) {
mMinZoom = aValue;
}
public float getMinZoom() {
return mMinZoom;
}
public void setMaxZoom(float aValue) {
mMaxZoom = aValue;
}
public float getMaxZoom() {
return mMaxZoom;
}
}

21
mobile/android/base/gfx/TouchEventHandler.java
View File

@ -60,7 +60,6 @@ public final class TouchEventHandler implements Tabs.OnTabsChangedListener {
private final GestureDetector mGestureDetector;
private final SimpleScaleGestureDetector mScaleGestureDetector;
private final PanZoomController mPanZoomController;
private final GestureDetector.OnDoubleTapListener mDoubleTapListener;
// the queue of events that we are holding on to while waiting for a preventDefault
// notification
@ -135,9 +134,7 @@ public final class TouchEventHandler implements Tabs.OnTabsChangedListener {
mListenerTimeoutProcessor = new ListenerTimeoutProcessor();
mDispatchEvents = true;
mDoubleTapListener = controller.getDoubleTapListener();
setDoubleTapEnabled(true);
mGestureDetector.setOnDoubleTapListener(controller.getDoubleTapListener());
Tabs.registerOnTabsChangedListener(this);
}
@ -216,11 +213,6 @@ public final class TouchEventHandler implements Tabs.OnTabsChangedListener {
mProcessingBalance--;
}
/* This function MUST be called on the UI thread. */
public void setDoubleTapEnabled(boolean aValue) {
mGestureDetector.setOnDoubleTapListener(aValue ? mDoubleTapListener : null);
}
/* This function MUST be called on the UI thread. */
public void setWaitForTouchListeners(boolean aValue) {
mWaitForTouchListeners = aValue;
@ -246,16 +238,7 @@ public final class TouchEventHandler implements Tabs.OnTabsChangedListener {
*/
private void dispatchEvent(MotionEvent event) {
if (mGestureDetector.onTouchEvent(event)) {
// An up/cancel event should get passed to both detectors, in
// case it comes from a pointer the scale detector is tracking.
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_POINTER_UP:
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
break;
default:
return;
}
return;
}
mScaleGestureDetector.onTouchEvent(event);
if (mScaleGestureDetector.isInProgress()) {

77
mobile/android/base/ui/PanZoomController.java
View File

@ -813,37 +813,19 @@ public class PanZoomController
float focusX = viewport.width() / 2.0f;
float focusY = viewport.height() / 2.0f;
float minZoomFactor = 0.0f;
float maxZoomFactor = MAX_ZOOM;
if (mController.getMinZoom() > 0)
minZoomFactor = mController.getMinZoom();
if (mController.getMaxZoom() > 0)
maxZoomFactor = mController.getMaxZoom();
if (!mController.getAllowZoom()) {
// If allowZoom is false, clamp to the default zoom level.
maxZoomFactor = minZoomFactor = mController.getDefaultZoom();
}
// Ensure minZoomFactor keeps the page at least as big as the viewport.
if (pageSize.width > 0) {
if (viewport.width() > pageSize.width && pageSize.width > 0) {
float scaleFactor = viewport.width() / pageSize.width;
minZoomFactor = Math.max(minZoomFactor, zoomFactor * scaleFactor);
if (viewport.width() > pageSize.width)
focusX = 0.0f;
focusX = 0.0f;
}
if (pageSize.height > 0) {
if (viewport.height() > pageSize.height && pageSize.height > 0) {
float scaleFactor = viewport.height() / pageSize.height;
minZoomFactor = Math.max(minZoomFactor, zoomFactor * scaleFactor);
if (viewport.height() > pageSize.height)
focusY = 0.0f;
focusY = 0.0f;
}
maxZoomFactor = Math.max(maxZoomFactor, minZoomFactor);
if (zoomFactor < minZoomFactor) {
if (!FloatUtils.fuzzyEquals(minZoomFactor, 0.0f)) {
// if one (or both) of the page dimensions is smaller than the viewport,
// zoom using the top/left as the focus on that axis. this prevents the
// scenario where, if both dimensions are smaller than the viewport, but
@ -851,9 +833,9 @@ public class PanZoomController
// after applying the scale
PointF center = new PointF(focusX, focusY);
viewportMetrics.scaleTo(minZoomFactor, center);
} else if (zoomFactor > maxZoomFactor) {
} else if (zoomFactor > MAX_ZOOM) {
PointF center = new PointF(viewport.width() / 2.0f, viewport.height() / 2.0f);
viewportMetrics.scaleTo(maxZoomFactor, center);
viewportMetrics.scaleTo(MAX_ZOOM, center);
}
/* Now we pan to the right origin. */
@ -893,9 +875,6 @@ public class PanZoomController
if (mState == PanZoomState.ANIMATED_ZOOM)
return false;
if (!mController.getAllowZoom())
return false;
mState = PanZoomState.PINCHING;
mLastZoomFocus = new PointF(detector.getFocusX(), detector.getFocusY());
cancelTouch();
@ -933,31 +912,13 @@ public class PanZoomController
synchronized (mController) {
float newZoomFactor = mController.getZoomFactor() * spanRatio;
float minZoomFactor = 0.0f;
float maxZoomFactor = MAX_ZOOM;
if (mController.getMinZoom() > 0)
minZoomFactor = mController.getMinZoom();
if (mController.getMaxZoom() > 0)
maxZoomFactor = mController.getMaxZoom();
if (newZoomFactor < minZoomFactor) {
// apply resistance when zooming past minZoomFactor,
// such that it asymptotically reaches minZoomFactor / 2.0
if (newZoomFactor >= MAX_ZOOM) {
// apply resistance when zooming past MAX_ZOOM,
// such that it asymptotically reaches MAX_ZOOM + 1.0
// but never exceeds that
final float rate = 0.5f; // controls how quickly we approach the limit
float excessZoom = minZoomFactor - newZoomFactor;
excessZoom = 1.0f - (float)Math.exp(-excessZoom * rate);
newZoomFactor = minZoomFactor * (1.0f - excessZoom / 2.0f);
}
if (newZoomFactor > maxZoomFactor) {
// apply resistance when zooming past maxZoomFactor,
// such that it asymptotically reaches maxZoomFactor + 1.0
// but never exceeds that
float excessZoom = newZoomFactor - maxZoomFactor;
float excessZoom = newZoomFactor - MAX_ZOOM;
excessZoom = 1.0f - (float)Math.exp(-excessZoom);
newZoomFactor = maxZoomFactor + excessZoom;
newZoomFactor = MAX_ZOOM + excessZoom;
}
mController.scrollBy(new PointF(mLastZoomFocus.x - detector.getFocusX(),
@ -1023,28 +984,14 @@ public class PanZoomController
sendPointToGecko("Gesture:LongPress", motionEvent);
}
@Override
public boolean onSingleTapUp(MotionEvent motionEvent) {
// When zooming is enabled, wait to see if there's a double-tap.
if (mController.getAllowZoom())
return false;
sendPointToGecko("Gesture:SingleTap", motionEvent);
return true;
}
@Override
public boolean onSingleTapConfirmed(MotionEvent motionEvent) {
// When zooming is disabled, we handle this in onSingleTapUp.
if (!mController.getAllowZoom())
return false;
sendPointToGecko("Gesture:SingleTap", motionEvent);
return true;
}
@Override
public boolean onDoubleTap(MotionEvent motionEvent) {
if (!mController.getAllowZoom())
return false;
sendPointToGecko("Gesture:DoubleTap", motionEvent);
return true;
}

72
mobile/android/chrome/content/browser.js
View File

@ -1616,7 +1616,6 @@ Tab.prototype = {
this.browser.addEventListener("pageshow", this, true);
Services.obs.addObserver(this, "before-first-paint", false);
Services.prefs.addObserver("browser.ui.zoom.force-user-scalable", this, false);
if (!aParams.delayLoad) {
let flags = "flags" in aParams ? aParams.flags : Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
@ -1661,7 +1660,6 @@ Tab.prototype = {
this.browser.removeEventListener("MozScrolledAreaChanged", this, true);
Services.obs.removeObserver(this, "before-first-paint");
Services.prefs.removeObserver("browser.ui.zoom.force-user-scalable", this);
// Make sure the previously selected panel remains selected. The selected panel of a deck is
// not stable when panels are removed.
@ -2352,10 +2350,6 @@ Tab.prototype = {
/** Update viewport when the metadata changes. */
updateViewportMetadata: function updateViewportMetadata(aMetadata) {
if (Services.prefs.getBoolPref("browser.ui.zoom.force-user-scalable")) {
aMetadata.allowZoom = true;
aMetadata.minZoom = aMetadata.maxZoom = NaN;
}
if (aMetadata && aMetadata.autoScale) {
let scaleRatio = aMetadata.scaleRatio = ViewportHandler.getScaleRatio();
@ -2368,7 +2362,6 @@ Tab.prototype = {
}
ViewportHandler.setMetadataForDocument(this.browser.contentDocument, aMetadata);
this.updateViewportSize(gScreenWidth);
this.sendViewportMetadata();
},
/** Update viewport when the metadata or the window size changes. */
@ -2422,7 +2415,13 @@ Tab.prototype = {
// on the layout at that width.
let oldBrowserWidth = this.browserWidth;
this.setBrowserSize(viewportW, viewportH);
let minScale = this.clampZoom(kViewportMinScale);
let minScale = 1.0;
if (this.browser.contentDocument) {
// this may get run during a Viewport:Change message while the document
// has not yet loaded, so need to guard against a null document.
let [pageWidth, pageHeight] = this.getPageSize(this.browser.contentDocument, viewportW, viewportH);
minScale = gScreenWidth / pageWidth;
}
viewportH = Math.max(viewportH, screenH / minScale);
this.setBrowserSize(viewportW, viewportH);
@ -2444,25 +2443,12 @@ Tab.prototype = {
// within the screen width. Note that "actual content" may be different
// with respect to CSS pixels because of the CSS viewport size changing.
let zoomScale = (screenW * oldBrowserWidth) / (aOldScreenWidth * viewportW);
let zoom = this.clampZoom(this._zoom * zoomScale);
this.setResolution(zoom, false);
this.setResolution(this._zoom * zoomScale, false);
this.sendViewportUpdate();
},
sendViewportMetadata: function sendViewportMetadata() {
sendMessageToJava({ gecko: {
type: "Tab:ViewportMetadata",
allowZoom: this.metadata.allowZoom,
defaultZoom: this.metadata.defaultZoom || 0,
minZoom: this.metadata.minZoom || 0,
maxZoom: this.metadata.maxZoom || 0,
tabID: this.id
}});
},
setBrowserSize: function(aWidth, aHeight) {
this.browserWidth = aWidth;
this.browserHeight = aHeight;
if (!this.browser.contentWindow)
return;
@ -2470,34 +2456,6 @@ Tab.prototype = {
cwu.setCSSViewport(aWidth, aHeight);
},
/** Returns the scale at which the page width will equal the screen width. */
getPageZoom: function getPageZoom(aZoom) {
// this may get run during a Viewport:Change message while the document
// has not yet loaded, so need to guard against a null document.
let doc = this.browser.contentDocument;
if (!doc)
return 1;
let [pageWidth, pageHeight] = this.getPageSize(doc, this.browserWidth, this.browserHeight);
return gScreenWidth / pageWidth;
},
/** Takes a scale and restricts it based on this tab's zoom limits. */
clampZoom: function clampZoom(aZoom) {
let md = this.metadata;
if (!md.allowZoom)
return md.defaultZoom || this.getPageZoom();
let zoom = ViewportHandler.clamp(aZoom, kViewportMinScale, kViewportMaxScale);
if (md && md.minZoom)
zoom = Math.max(zoom, md.minZoom);
if (md && md.maxZoom)
zoom = Math.min(zoom, md.maxZoom);
zoom = Math.max(zoom, this.getPageZoom());
return zoom;
},
getRequestLoadContext: function(aRequest) {
if (aRequest && aRequest.notificationCallbacks) {
try {
@ -2558,10 +2516,6 @@ Tab.prototype = {
this.contentDocumentIsDisplayed = true;
}
break;
case "nsPref:changed":
if (aData == "browser.ui.zoom.force-user-scalable")
ViewportHandler.updateMetadata(this);
break;
}
},
@ -3706,16 +3660,16 @@ var ViewportHandler = {
if (scale == NaN && minScale == NaN && maxScale == NaN && allowZoomStr == "" && widthStr == "" && heightStr == "") {
// Only check for HandheldFriendly if we don't have a viewport meta tag
let handheldFriendly = windowUtils.getDocumentMetadata("HandheldFriendly");
// Only check for HandheldFriendly if we don't have a viewport meta tag
let handheldFriendly = windowUtils.getDocumentMetadata("HandheldFriendly");
if (handheldFriendly == "true")
return { defaultZoom: 1, autoSize: true, allowZoom: true, autoScale: true };
if (handheldFriendly == "true")
return { defaultZoom: 1, autoSize: true, allowZoom: true, autoScale: true };
}
scale = this.clamp(scale, kViewportMinScale, kViewportMaxScale);
minScale = this.clamp(minScale, kViewportMinScale, kViewportMaxScale);
maxScale = this.clamp(maxScale, minScale, kViewportMaxScale);
maxScale = this.clamp(maxScale, kViewportMinScale, kViewportMaxScale);
// If initial scale is 1.0 and width is not set, assume width=device-width
let autoSize = (widthStr == "device-width" ||