--- a/mobile/android/base/gfx/GeckoLayerClient.java
+++ b/mobile/android/base/gfx/GeckoLayerClient.java
@@ -358,17 +358,17 @@ public class GeckoLayerClient implements
       * The compositor invokes this function whenever it determines that the page rect
       * has changed (based on the information it gets from layout). If setFirstPaintViewport
       * is invoked on a frame, then this function will not be. For any given frame, this
       * function will be invoked before syncViewportInfo.
       */
     public void setPageRect(float cssPageLeft, float cssPageTop, float cssPageRight, float cssPageBottom) {
         synchronized (mLayerController) {
             RectF cssPageRect = new RectF(cssPageLeft, cssPageTop, cssPageRight, cssPageBottom);
-            float ourZoom = mLayerController.getZoomFactor();
+            float ourZoom = mLayerController.getViewportMetrics().zoomFactor;
             mLayerController.setPageRect(RectUtils.scale(cssPageRect, ourZoom), cssPageRect);
             // Here the page size of the document has changed, but the document being displayed
             // is still the same. Therefore, we don't need to send anything to browser.js; any
             // changes we need to make to the display port will get sent the next time we call
             // adjustViewport().
         }
     }
 

--- a/mobile/android/base/gfx/LayerController.java
+++ b/mobile/android/base/gfx/LayerController.java
@@ -92,28 +92,20 @@ public class LayerController {
         mForceRedraw = true;
     }
 
     public Layer getRoot()                        { return mRootLayer; }
     public LayerView getView()                    { return mView; }
     public Context getContext()                   { return mContext; }
     public ImmutableViewportMetrics getViewportMetrics()   { return mViewportMetrics; }
 
-    public RectF getViewport() {
-        return mViewportMetrics.getViewport();
-    }
-
     public FloatSize getViewportSize() {
         return mViewportMetrics.getSize();
     }
 
-    public float getZoomFactor() {
-        return mViewportMetrics.zoomFactor;
-    }
-
     public Bitmap getBackgroundPattern()    { return getDrawable("tabs_tray_selected_bg"); }
     public Bitmap getShadowPattern()        { return getDrawable("shadow"); }
 
     public PanZoomController getPanZoomController()                                 { return mPanZoomController; }
     public GestureDetector.OnGestureListener getGestureListener()                   { return mPanZoomController; }
     public SimpleScaleGestureDetector.SimpleScaleGestureListener getScaleGestureListener() {
         return mPanZoomController;
     }

--- a/mobile/android/base/gfx/LayerRenderer.java
+++ b/mobile/android/base/gfx/LayerRenderer.java
@@ -534,17 +534,17 @@ public class LayerRenderer {
 
             /* Draw the background. */
             mBackgroundLayer.setMask(mPageRect);
             mBackgroundLayer.draw(mScreenContext);
 
             /* Draw the drop shadow, if we need to. */
             RectF untransformedPageRect = new RectF(0.0f, 0.0f, mPageRect.width(),
                                                     mPageRect.height());
-            if (!untransformedPageRect.contains(mView.getController().getViewport()))
+            if (!untransformedPageRect.contains(mFrameMetrics.getViewport()))
                 mShadowLayer.draw(mPageContext);
 
             /* Draw the 'checkerboard'. We use gfx.show_checkerboard_pattern to
              * determine whether to draw the screenshot layer.
              */
             if (mView.getController().checkerboardShouldShowChecks()) {
                 /* Find the area the root layer will render into, to mask the checkerboard layer */
                 Rect rootMask = getMaskForLayer(mView.getController().getRoot());

--- a/mobile/android/base/ui/PanZoomController.java
+++ b/mobile/android/base/ui/PanZoomController.java
@@ -907,17 +907,17 @@ public class PanZoomController
          */
         float resistance = Math.min(mX.getEdgeResistance(), mY.getEdgeResistance());
         if (spanRatio > 1.0f)
             spanRatio = 1.0f + (spanRatio - 1.0f) * resistance;
         else
             spanRatio = 1.0f - (1.0f - spanRatio) * resistance;
 
         synchronized (mController) {
-            float newZoomFactor = mController.getZoomFactor() * spanRatio;
+            float newZoomFactor = getMetrics().zoomFactor * spanRatio;
             float minZoomFactor = 0.0f;
             float maxZoomFactor = MAX_ZOOM;
 
             ZoomConstraints constraints = mController.getZoomConstraints();
 
             if (constraints.getMinZoom() > 0)
                 minZoomFactor = constraints.getMinZoom();
             if (constraints.getMaxZoom() > 0)
@@ -1038,19 +1038,19 @@ public class PanZoomController
     /**
      * Zoom to a specified rect IN CSS PIXELS.
      *
      * While we usually use device pixels, @zoomToRect must be specified in CSS
      * pixels.
      */
     private boolean animatedZoomTo(RectF zoomToRect) {
         setState(PanZoomState.ANIMATED_ZOOM);
-        final float startZoom = mController.getZoomFactor();
+        final float startZoom = getMetrics().zoomFactor;
 
-        RectF viewport = mController.getViewport();
+        RectF viewport = getMetrics().getViewport();
         // 1. adjust the aspect ratio of zoomToRect to match that of the current viewport,
         // enlarging as necessary (if it gets too big, it will get shrunk in the next step).
         // while enlarging make sure we enlarge equally on both sides to keep the target rect
         // centered.
         float targetRatio = viewport.width() / viewport.height();
         float rectRatio = zoomToRect.width() / zoomToRect.height();
         if (FloatUtils.fuzzyEquals(targetRatio, rectRatio)) {
             // all good, do nothing