backout bug 1096132 for Mac build failure
authorKarl Tomlinson <karlt+@karlt.net>
Wed, 12 Nov 2014 16:02:34 +1300
changeset 215159 f96e3c57e1d838c5e99b9cfd7731811f3184050b
parent 215158 39fcd286ce68e385d10155e9b3dcd785c83db95d
child 215160 e59e29b14cd6969a7b29b7c7f4adb6f38649fc6a
push id27810
push usercbook@mozilla.com
push dateWed, 12 Nov 2014 15:03:31 +0000
treeherdermozilla-central@cf9eafef4ffa [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1096132
milestone36.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
backout bug 1096132 for Mac build failure
dom/base/nsDOMWindowUtils.cpp
dom/events/Event.cpp
dom/events/UIEvent.h
gfx/src/nsDeviceContext.cpp
gfx/src/nsDeviceContext.h
layout/base/nsDocumentViewer.cpp
layout/base/nsPresContext.cpp
layout/style/nsRuleNode.cpp
layout/xul/nsMenuPopupFrame.cpp
view/nsView.cpp
widget/nsBaseDragService.cpp
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -2063,17 +2063,17 @@ nsDOMWindowUtils::GetFullZoom(float* aFu
 
   MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
 
   nsPresContext* presContext = GetPresContext();
   if (!presContext) {
     return NS_OK;
   }
 
-  *aFullZoom = presContext->DeviceContext()->GetFullZoom();
+  *aFullZoom = presContext->DeviceContext()->GetPixelScale();
 
   return NS_OK;
 }
  
 NS_IMETHODIMP
 nsDOMWindowUtils::DispatchDOMEventViaPresShell(nsIDOMNode* aTarget,
                                                nsIDOMEvent* aEvent,
                                                bool aTrusted,
--- a/dom/events/Event.cpp
+++ b/dom/events/Event.cpp
@@ -881,18 +881,17 @@ Event::GetScreenCoords(nsPresContext* aP
 
   WidgetGUIEvent* guiEvent = aEvent->AsGUIEvent();
   if (!guiEvent->widget) {
     return LayoutDeviceIntPoint::ToUntyped(aPoint);
   }
 
   LayoutDeviceIntPoint offset = aPoint +
     LayoutDeviceIntPoint::FromUntyped(guiEvent->widget->WidgetToScreenOffset());
-  nscoord factor =
-    aPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom();
+  nscoord factor = aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
   return nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(offset.x * factor),
                     nsPresContext::AppUnitsToIntCSSPixels(offset.y * factor));
 }
 
 // static
 CSSIntPoint
 Event::GetPageCoords(nsPresContext* aPresContext,
                      WidgetEvent* aEvent,
--- a/dom/events/UIEvent.h
+++ b/dom/events/UIEvent.h
@@ -55,17 +55,17 @@ public:
     WidgetGUIEvent* event = aEvent->AsGUIEvent();
     if (!event->widget) {
       return LayoutDeviceIntPoint::ToUntyped(aEvent->refPoint);
     }
 
     LayoutDeviceIntPoint offset = aEvent->refPoint +
       LayoutDeviceIntPoint::FromUntyped(event->widget->WidgetToScreenOffset());
     nscoord factor =
-      aPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom();
+      aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
     return nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(offset.x * factor),
                       nsPresContext::AppUnitsToIntCSSPixels(offset.y * factor));
   }
 
   static CSSIntPoint CalculateClientPoint(nsPresContext* aPresContext,
                                           WidgetEvent* aEvent,
                                           CSSIntPoint* aDefaultClientPoint)
   {
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -239,19 +239,19 @@ nsFontCache::Flush()
         fm->Destroy();
         NS_RELEASE(fm);
     }
     mFontMetrics.Clear();
 }
 
 nsDeviceContext::nsDeviceContext()
     : mWidth(0), mHeight(0), mDepth(0),
-      mAppUnitsPerDevPixel(-1), mAppUnitsPerDevPixelAtUnitFullZoom(-1),
+      mAppUnitsPerDevPixel(-1), mAppUnitsPerDevNotScaledPixel(-1),
       mAppUnitsPerPhysicalInch(-1),
-      mFullZoom(1.0f), mPrintingScale(1.0f),
+      mPixelScale(1.0f), mPrintingScale(1.0f),
       mFontCache(nullptr)
 {
     MOZ_ASSERT(NS_IsMainThread(), "nsDeviceContext created off main thread");
 }
 
 // Note: we use a bare pointer for mFontCache so that nsFontCache
 // can be an incomplete type in nsDeviceContext.h.
 // Therefore we have to do all the refcounting by hand.
@@ -328,17 +328,17 @@ nsDeviceContext::SetDPI()
             break;
         }
 #endif
         default:
             NS_NOTREACHED("Unexpected printing surface type");
             break;
         }
 
-        mAppUnitsPerDevPixelAtUnitFullZoom =
+        mAppUnitsPerDevNotScaledPixel =
             NS_lround((AppUnitsPerCSSPixel() * 96) / dpi);
     } else {
         // A value of -1 means use the maximum of 96 and the system DPI.
         // A value of 0 means use the system DPI. A positive value is used as the DPI.
         // This sets the physical size of a device pixel and thus controls the
         // interpretation of physical units.
         int32_t prefDPI = Preferences::GetInt("layout.css.dpi", -1);
 
@@ -353,24 +353,24 @@ nsDeviceContext::SetDPI()
         } else {
             dpi = 96.0f;
         }
 
         CSSToLayoutDeviceScale scale = mWidget ? mWidget->GetDefaultScale()
                                                : CSSToLayoutDeviceScale(1.0);
         double devPixelsPerCSSPixel = scale.scale;
 
-        mAppUnitsPerDevPixelAtUnitFullZoom =
+        mAppUnitsPerDevNotScaledPixel =
             std::max(1, NS_lround(AppUnitsPerCSSPixel() / devPixelsPerCSSPixel));
     }
 
     NS_ASSERTION(dpi != -1.0, "no dpi set");
 
-    mAppUnitsPerPhysicalInch = NS_lround(dpi * mAppUnitsPerDevPixelAtUnitFullZoom);
-    UpdateAppUnitsForFullZoom();
+    mAppUnitsPerPhysicalInch = NS_lround(dpi * mAppUnitsPerDevNotScaledPixel);
+    UpdateScaledAppUnits();
 }
 
 nsresult
 nsDeviceContext::Init(nsIWidget *aWidget)
 {
     if (mScreenManager && mWidget == aWidget)
         return NS_OK;
 
@@ -717,38 +717,38 @@ nsDeviceContext::CalcPrintingSize()
         mHeight = NSToCoordRound(float(size.height) * AppUnitsPerPhysicalInch() / 72);
     } else {
         mWidth = NSToIntRound(size.width);
         mHeight = NSToIntRound(size.height);
     }
 }
 
 bool nsDeviceContext::CheckDPIChange() {
-    int32_t oldDevPixels = mAppUnitsPerDevPixelAtUnitFullZoom;
+    int32_t oldDevPixels = mAppUnitsPerDevNotScaledPixel;
     int32_t oldInches = mAppUnitsPerPhysicalInch;
 
     SetDPI();
 
-    return oldDevPixels != mAppUnitsPerDevPixelAtUnitFullZoom ||
+    return oldDevPixels != mAppUnitsPerDevNotScaledPixel ||
         oldInches != mAppUnitsPerPhysicalInch;
 }
 
 bool
-nsDeviceContext::SetFullZoom(float aScale)
+nsDeviceContext::SetPixelScale(float aScale)
 {
     if (aScale <= 0) {
-        NS_NOTREACHED("Invalid full zoom value");
+        NS_NOTREACHED("Invalid pixel scale value");
         return false;
     }
     int32_t oldAppUnitsPerDevPixel = mAppUnitsPerDevPixel;
-    mFullZoom = aScale;
-    UpdateAppUnitsForFullZoom();
+    mPixelScale = aScale;
+    UpdateScaledAppUnits();
     return oldAppUnitsPerDevPixel != mAppUnitsPerDevPixel;
 }
 
 void
-nsDeviceContext::UpdateAppUnitsForFullZoom()
+nsDeviceContext::UpdateScaledAppUnits()
 {
     mAppUnitsPerDevPixel =
-        std::max(1, NSToIntRound(float(mAppUnitsPerDevPixelAtUnitFullZoom) / mFullZoom));
-    // adjust mFullZoom to reflect appunit rounding
-    mFullZoom = float(mAppUnitsPerDevPixelAtUnitFullZoom) / mAppUnitsPerDevPixel;
+        std::max(1, NSToIntRound(float(mAppUnitsPerDevNotScaledPixel) / mPixelScale));
+    // adjust mPixelScale to reflect appunit rounding
+    mPixelScale = float(mAppUnitsPerDevNotScaledPixel) / mAppUnitsPerDevPixel;
 }
--- a/gfx/src/nsDeviceContext.h
+++ b/gfx/src/nsDeviceContext.h
@@ -98,21 +98,21 @@ public:
 
     /**
      * Gets the number of app units in one CSS inch; this is
      * 96 times AppUnitsPerCSSPixel.
      */
     static int32_t AppUnitsPerCSSInch() { return mozilla::AppUnitsPerCSSInch(); }
 
     /**
-     * Get the ratio of app units to dev pixels that would be used at unit
-     * (100%) full zoom.
+     * Get the unscaled ratio of app units to dev pixels; useful if something
+     * needs to be converted from to unscaled pixels
      */
-    int32_t AppUnitsPerDevPixelAtUnitFullZoom() const
-    { return mAppUnitsPerDevPixelAtUnitFullZoom; }
+    int32_t UnscaledAppUnitsPerDevPixel() const
+    { return mAppUnitsPerDevNotScaledPixel; }
 
     /**
      * Get the nsFontMetrics that describe the properties of
      * an nsFont.
      * @param aFont font description to obtain metrics for
      * @param aLanguage the language of the document
      * @param aMetrics out parameter for font metrics
      * @param aUserFontSet user font set
@@ -229,50 +229,50 @@ public:
      * Check to see if the DPI has changed
      * @return whether there was actually a change in the DPI (whether
      *         AppUnitsPerDevPixel() or AppUnitsPerPhysicalInch()
      *         changed)
      */
     bool CheckDPIChange();
 
     /**
-     * Set the full zoom factor: all lengths are multiplied by this factor
+     * Set the pixel scaling factor: all lengths are multiplied by this factor
      * when we convert them to device pixels. Returns whether the ratio of
-     * app units to dev pixels changed because of the zoom factor.
+     * app units to dev pixels changed because of the scale factor.
      */
-    bool SetFullZoom(float aScale);
+    bool SetPixelScale(float aScale);
 
     /**
-     * Returns the page full zoom factor applied.
+     * Returns the pixel scaling factor (page zoom factor) applied.
      */
-    float GetFullZoom() const { return mFullZoom; }
+    float GetPixelScale() const { return mPixelScale; }
 
     /**
      * True if this device context was created for printing.
      */
     bool IsPrinterSurface();
 
 private:
     // Private destructor, to discourage deletion outside of Release():
     ~nsDeviceContext();
 
     void SetDPI();
     void ComputeClientRectUsingScreen(nsRect *outRect);
     void ComputeFullAreaUsingScreen(nsRect *outRect);
     void FindScreen(nsIScreen **outScreen);
     void CalcPrintingSize();
-    void UpdateAppUnitsForFullZoom();
+    void UpdateScaledAppUnits();
 
     nscoord  mWidth;
     nscoord  mHeight;
     uint32_t mDepth;
     int32_t  mAppUnitsPerDevPixel;
-    int32_t  mAppUnitsPerDevPixelAtUnitFullZoom;
+    int32_t  mAppUnitsPerDevNotScaledPixel;
     int32_t  mAppUnitsPerPhysicalInch;
-    float    mFullZoom;
+    float    mPixelScale;
     float    mPrintingScale;
 
     nsFontCache*                   mFontCache;
     nsCOMPtr<nsIWidget>            mWidget;
     nsCOMPtr<nsIScreenManager>     mScreenManager;
     nsCOMPtr<nsIDeviceContextSpec> mDeviceContextSpec;
     nsRefPtr<gfxASurface>          mPrintingSurface;
 #ifdef XP_MACOSX
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -660,18 +660,17 @@ nsDocumentViewer::InitPresentationStuff(
 
     mDocument->FlushPendingNotifications(Flush_ContentAndNotify);
   }
 
   mPresShell->BeginObservingDocument();
 
   // Initialize our view manager
   int32_t p2a = mPresContext->AppUnitsPerDevPixel();
-  MOZ_ASSERT(p2a ==
-             mPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom());
+  MOZ_ASSERT(p2a == mPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel());
   nscoord width = p2a * mBounds.width;
   nscoord height = p2a * mBounds.height;
 
   mViewManager->SetWindowDimensions(width, height);
   mPresContext->SetTextZoom(mTextZoom);
   mPresContext->SetFullZoom(mPageZoom);
   mPresContext->SetBaseMinFontSize(mMinFontSize);
 
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -952,17 +952,17 @@ nsPresContext::UpdateAfterPreferencesCha
 nsresult
 nsPresContext::Init(nsDeviceContext* aDeviceContext)
 {
   NS_ASSERTION(!mInitialized, "attempt to reinit pres context");
   NS_ENSURE_ARG(aDeviceContext);
 
   mDeviceContext = aDeviceContext;
 
-  if (mDeviceContext->SetFullZoom(mFullZoom))
+  if (mDeviceContext->SetPixelScale(mFullZoom))
     mDeviceContext->FlushFontCache();
   mCurAppUnitsPerDevPixel = AppUnitsPerDevPixel();
 
   mEventManager = new mozilla::EventStateManager();
 
   mTransitionManager = new nsTransitionManager(this);
 
   mAnimationManager = new nsAnimationManager(this);
@@ -1470,17 +1470,17 @@ nsPresContext::SetFullZoom(float aZoom)
   }
 
   // Re-fetch the view manager's window dimensions in case there's a deferred
   // resize which hasn't affected our mVisibleArea yet
   nscoord oldWidthAppUnits, oldHeightAppUnits;
   mShell->GetViewManager()->GetWindowDimensions(&oldWidthAppUnits, &oldHeightAppUnits);
   float oldWidthDevPixels = oldWidthAppUnits / float(mCurAppUnitsPerDevPixel);
   float oldHeightDevPixels = oldHeightAppUnits / float(mCurAppUnitsPerDevPixel);
-  mDeviceContext->SetFullZoom(aZoom);
+  mDeviceContext->SetPixelScale(aZoom);
 
   NS_ASSERTION(!mSupressResizeReflow, "two zooms happening at the same time? impossible!");
   mSupressResizeReflow = true;
 
   mFullZoom = aZoom;
   mShell->GetViewManager()->
     SetWindowDimensions(NSToCoordRound(oldWidthDevPixels * AppUnitsPerDevPixel()),
                         NSToCoordRound(oldHeightDevPixels * AppUnitsPerDevPixel()));
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -3382,31 +3382,30 @@ nsRuleNode::SetFont(nsPresContext* aPres
   nsFont systemFont = *defaultVariableFont;
   const nsCSSValue* systemFontValue = aRuleData->ValueForSystemFont();
   if (eCSSUnit_Enumerated == systemFontValue->GetUnit()) {
     gfxFontStyle fontStyle;
     LookAndFeel::FontID fontID =
       (LookAndFeel::FontID)systemFontValue->GetIntValue();
     float devPerCSS =
       (float)nsPresContext::AppUnitsPerCSSPixel() /
-      aPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom();
+      aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
     nsAutoString systemFontName;
     if (LookAndFeel::GetFont(fontID, systemFontName, fontStyle, devPerCSS)) {
       systemFontName.Trim("\"'");
       systemFont.fontlist = FontFamilyList(systemFontName, eUnquotedName);
       systemFont.fontlist.SetDefaultFontType(eFamily_none);
       systemFont.style = fontStyle.style;
       systemFont.systemFont = fontStyle.systemFont;
       systemFont.weight = fontStyle.weight;
       systemFont.stretch = fontStyle.stretch;
       systemFont.decorations = NS_FONT_DECORATION_NONE;
-      systemFont.size =
-        NSFloatPixelsToAppUnits(fontStyle.size,
-                                aPresContext->DeviceContext()->
-                                  AppUnitsPerDevPixelAtUnitFullZoom());
+      systemFont.size = NSFloatPixelsToAppUnits(fontStyle.size,
+                                                aPresContext->DeviceContext()->
+                                                UnscaledAppUnitsPerDevPixel());
       //systemFont.langGroup = fontStyle.langGroup;
       systemFont.sizeAdjust = fontStyle.sizeAdjust;
 
 #ifdef XP_WIN
       // XXXldb This platform-specific stuff should be in the
       // LookAndFeel implementation, not here.
       // XXXzw Should we even still *have* this code?  It looks to be making
       // old, probably obsolete assumptions.
--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -1295,30 +1295,30 @@ nsMenuPopupFrame::SetPopupPosition(nsIFr
       // the next time SetPopupPosition is called.
       mScreenXPos = presContext->AppUnitsToIntCSSPixels(screenPoint.x - margin.left);
       mScreenYPos = presContext->AppUnitsToIntCSSPixels(screenPoint.y - margin.top);
     }
   }
   else {
     // the popup is positioned at a screen coordinate.
     // first convert the screen position in mScreenXPos and mScreenYPos from
-    // CSS pixels into device pixels, ignoring any zoom as mScreenXPos and
-    // mScreenYPos are unzoomed screen coordinates.
-    int32_t factor = devContext->AppUnitsPerDevPixelAtUnitFullZoom();
+    // CSS pixels into device pixels, ignoring any scaling as mScreenXPos and
+    // mScreenYPos are unscaled screen coordinates.
+    int32_t factor = devContext->UnscaledAppUnitsPerDevPixel();
 
     // context menus should be offset by two pixels so that they don't appear
     // directly where the cursor is. Otherwise, it is too easy to have the
     // context menu close up again.
     if (mAdjustOffsetForContextMenu) {
       int32_t offsetForContextMenuDev =
         nsPresContext::CSSPixelsToAppUnits(CONTEXT_MENU_OFFSET_PIXELS) / factor;
       offsetForContextMenu = presContext->DevPixelsToAppUnits(offsetForContextMenuDev);
     }
 
-    // next, convert into app units accounting for the zoom
+    // next, convert into app units accounting for the scaling
     screenPoint.x = presContext->DevPixelsToAppUnits(
                       nsPresContext::CSSPixelsToAppUnits(mScreenXPos) / factor);
     screenPoint.y = presContext->DevPixelsToAppUnits(
                       nsPresContext::CSSPixelsToAppUnits(mScreenYPos) / factor);
     anchorRect = nsRect(screenPoint, nsSize(0, 0));
 
     // add the margins on the popup
     screenPoint.MoveBy(margin.left + offsetForContextMenu,
--- a/view/nsView.cpp
+++ b/view/nsView.cpp
@@ -332,24 +332,24 @@ void nsView::DoResetWidgetBounds(bool aM
 
   // Bug 861270: for correct widget manipulation at arbitrary scale factors,
   // prefer to base scaling on widget->GetDefaultScale(). But only do this if
   // it matches the view manager's device context scale after allowing for the
   // quantization to app units, because of OS X multiscreen issues (where the
   // only two scales are 1.0 or 2.0, and so the quantization doesn't actually
   // cause problems anyhow).
   // In the case of a mismatch, fall back to scaling based on the dev context's
-  // AppUnitsPerDevPixelAtUnitFullZoom value. On platforms where the device-pixel
+  // unscaledAppUnitsPerDevPixel value. On platforms where the device-pixel
   // scale is uniform across all displays (currently all except OS X), we'll
   // always use the precise value from mWindow->GetDefaultScale here.
   CSSToLayoutDeviceScale scale = widget->GetDefaultScale();
-  if (NSToIntRound(60.0 / scale.scale) == dx->AppUnitsPerDevPixelAtUnitFullZoom()) {
+  if (NSToIntRound(60.0 / scale.scale) == dx->UnscaledAppUnitsPerDevPixel()) {
     invScale = 1.0 / scale.scale;
   } else {
-    invScale = dx->AppUnitsPerDevPixelAtUnitFullZoom() / 60.0;
+    invScale = dx->UnscaledAppUnitsPerDevPixel() / 60.0;
   }
 
   if (changedPos) {
     if (changedSize && !aMoveOnly) {
       widget->ResizeClient(newBounds.x * invScale,
                            newBounds.y * invScale,
                            newBounds.width * invScale,
                            newBounds.height * invScale,
--- a/widget/nsBaseDragService.cpp
+++ b/widget/nsBaseDragService.cpp
@@ -643,17 +643,17 @@ nsBaseDragService::DrawDragForImage(nsPr
 
   return result;
 }
 
 void
 nsBaseDragService::ConvertToUnscaledDevPixels(nsPresContext* aPresContext,
                                               int32_t* aScreenX, int32_t* aScreenY)
 {
-  int32_t adj = aPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom();
+  int32_t adj = aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
   *aScreenX = nsPresContext::CSSPixelsToAppUnits(*aScreenX) / adj;
   *aScreenY = nsPresContext::CSSPixelsToAppUnits(*aScreenY) / adj;
 }
 
 NS_IMETHODIMP
 nsBaseDragService::Suppress()
 {
   EndDragSession(false);