diff --git a/mozilla/layout/base/nsPresShell.cpp b/mozilla/layout/base/nsPresShell.cpp
index 838a3f73ef4..1b7e8611a0e 100644
--- a/mozilla/layout/base/nsPresShell.cpp
+++ b/mozilla/layout/base/nsPresShell.cpp
@@ -5704,21 +5704,21 @@ PresShell::HandleEvent(nsIView         *aView,
 
       nsPoint originOffset;
       nsIView *view = nsnull;
-      frame->GetOriginToViewOffset(mPresContext, originOffset, &view);
+      frame->GetOriginToViewOffset(originOffset, &view);
 
       NS_ASSERTION(view == aView, "view != aView");
       if (view == aView)
         eventPoint -= originOffset;
 
-      rv = frame->GetFrameForPoint(mPresContext, eventPoint,
+      rv = frame->GetFrameForPoint(eventPoint,
                                    NS_FRAME_PAINT_LAYER_FOREGROUND,
                                    &mCurrentEventFrame);
       if (NS_FAILED(rv)) {
-        rv = frame->GetFrameForPoint(mPresContext, eventPoint,
+        rv = frame->GetFrameForPoint(eventPoint,
                                      NS_FRAME_PAINT_LAYER_FLOATS,
                                      &mCurrentEventFrame);
         if (NS_FAILED(rv)) {
-          rv = frame->GetFrameForPoint(mPresContext, eventPoint,
+          rv = frame->GetFrameForPoint(eventPoint,
                                        NS_FRAME_PAINT_LAYER_BACKGROUND,
                                        &mCurrentEventFrame);
           if (NS_FAILED (rv)) {
diff --git a/mozilla/layout/forms/nsFieldSetFrame.cpp b/mozilla/layout/forms/nsFieldSetFrame.cpp
index 12a38b975da..4a4292df47a 100644
--- a/mozilla/layout/forms/nsFieldSetFrame.cpp
+++ b/mozilla/layout/forms/nsFieldSetFrame.cpp
@@ -102,8 +102,7 @@ public:
                            nsIAtom*        aListName,
                            nsIFrame*       aOldFrame,
                            nsIFrame*       aNewFrame);
-  NS_IMETHOD  GetFrameForPoint(nsPresContext*   aPresContext,
-                               const nsPoint&    aPoint, 
+  NS_IMETHOD  GetFrameForPoint(const nsPoint&    aPoint, 
                                nsFramePaintLayer aWhichLayer,
                                nsIFrame**        aFrame);
   virtual nsIAtom* GetType() const;
@@ -662,13 +661,12 @@ nsFieldSetFrame::ReplaceFrame(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP
-nsFieldSetFrame::GetFrameForPoint(nsPresContext*   aPresContext,
-                     const nsPoint&    aPoint, 
+nsFieldSetFrame::GetFrameForPoint(const nsPoint&    aPoint, 
                      nsFramePaintLayer aWhichLayer,
                      nsIFrame**        aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
 }
 
 #ifdef ACCESSIBILITY
diff --git a/mozilla/layout/forms/nsFileControlFrame.cpp b/mozilla/layout/forms/nsFileControlFrame.cpp
index 2d6db6cf3db..e95d40eac0a 100644
--- a/mozilla/layout/forms/nsFileControlFrame.cpp
+++ b/mozilla/layout/forms/nsFileControlFrame.cpp
@@ -567,8 +567,7 @@ nsFileControlFrame::AttributeChanged(nsIContent*     aChild,
 }
 
 NS_IMETHODIMP
-nsFileControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint,
+nsFileControlFrame::GetFrameForPoint(const nsPoint& aPoint,
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame** aFrame)
 {
@@ -579,7 +578,7 @@ nsFileControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
       return NS_OK;
     }
   } else {
-    return nsAreaFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+    return nsAreaFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
   }
 #endif
   return NS_ERROR_FAILURE;
diff --git a/mozilla/layout/forms/nsFileControlFrame.h b/mozilla/layout/forms/nsFileControlFrame.h
index 158d2bbfbbd..19898ef0af7 100644
--- a/mozilla/layout/forms/nsFileControlFrame.h
+++ b/mozilla/layout/forms/nsFileControlFrame.h
@@ -97,7 +97,7 @@ public:
   NS_IMETHOD GetFrameName(nsAString& aResult) const;
 #endif
   NS_IMETHOD SetSuggestedSize(nscoord aWidth, nscoord aHeight) { return NS_OK; };
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
   NS_IMETHOD AttributeChanged(nsIContent*     aChild,
                               PRInt32         aNameSpaceID,
                               nsIAtom*        aAttribute,
diff --git a/mozilla/layout/forms/nsFormControlFrame.cpp b/mozilla/layout/forms/nsFormControlFrame.cpp
index 8f707cb9ab9..3837c34fa9b 100644
--- a/mozilla/layout/forms/nsFormControlFrame.cpp
+++ b/mozilla/layout/forms/nsFormControlFrame.cpp
@@ -433,22 +433,21 @@ nsFormControlFrame::Paint(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsFormControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint,
+nsFormControlFrame::GetFrameForPoint(const nsPoint& aPoint,
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame** aFrame)
 {
   nsresult rv = NS_ERROR_FAILURE;
   if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
-    rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsLeafFrame::GetFrameForPoint(aPoint,
                                       NS_FRAME_PAINT_LAYER_FOREGROUND, aFrame);
     if (NS_SUCCEEDED(rv))
       return NS_OK;
-    rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsLeafFrame::GetFrameForPoint(aPoint,
                                        NS_FRAME_PAINT_LAYER_FLOATS, aFrame);
     if (NS_SUCCEEDED(rv))
       return NS_OK;
-    rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsLeafFrame::GetFrameForPoint(aPoint,
                                       NS_FRAME_PAINT_LAYER_BACKGROUND, aFrame);
   }
   return rv;
diff --git a/mozilla/layout/forms/nsFormControlFrame.h b/mozilla/layout/forms/nsFormControlFrame.h
index dc02b449ce4..6b390d96c64 100644
--- a/mozilla/layout/forms/nsFormControlFrame.h
+++ b/mozilla/layout/forms/nsFormControlFrame.h
@@ -114,8 +114,7 @@ public:
                    nsFramePaintLayer    aWhichLayer,
                    PRUint32             aFlags = 0);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame** aFrame);
 
diff --git a/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp b/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp
index eeee92deaca..50c482471e2 100644
--- a/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -285,8 +285,7 @@ nsHTMLButtonControlFrame::HandleEvent(nsPresContext* aPresContext,
 
 
 NS_IMETHODIMP
-nsHTMLButtonControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                           const nsPoint& aPoint,
+nsHTMLButtonControlFrame::GetFrameForPoint(const nsPoint& aPoint,
                                            nsFramePaintLayer aWhichLayer,
                                            nsIFrame** aFrame)
 {
diff --git a/mozilla/layout/forms/nsHTMLButtonControlFrame.h b/mozilla/layout/forms/nsHTMLButtonControlFrame.h
index e773b4bab26..6ea7bfac473 100644
--- a/mozilla/layout/forms/nsHTMLButtonControlFrame.h
+++ b/mozilla/layout/forms/nsHTMLButtonControlFrame.h
@@ -85,7 +85,7 @@ public:
                          nsGUIEvent* aEvent,
                          nsEventStatus* aEventStatus);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
 
   NS_IMETHOD SetInitialChildList(nsPresContext* aPresContext,
                                  nsIAtom*        aListName,
diff --git a/mozilla/layout/forms/nsSelectsAreaFrame.cpp b/mozilla/layout/forms/nsSelectsAreaFrame.cpp
index e43405f291d..416f68fcd5b 100644
--- a/mozilla/layout/forms/nsSelectsAreaFrame.cpp
+++ b/mozilla/layout/forms/nsSelectsAreaFrame.cpp
@@ -103,8 +103,7 @@ nsSelectsAreaFrame::IsOptionElementFrame(nsIFrame *aFrame)
 
 //---------------------------------------------------------
 NS_IMETHODIMP
-nsSelectsAreaFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint,
+nsSelectsAreaFrame::GetFrameForPoint(const nsPoint& aPoint,
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame** aFrame)
 {
@@ -115,7 +114,7 @@ nsSelectsAreaFrame::GetFrameForPoint(nsPresContext* aPresContext,
     return NS_ERROR_FAILURE;
   }
 
-  nsresult result = nsAreaFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  nsresult result = nsAreaFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 
   if (result == NS_OK) {
     nsIFrame* selectedFrame = *aFrame;
diff --git a/mozilla/layout/forms/nsSelectsAreaFrame.h b/mozilla/layout/forms/nsSelectsAreaFrame.h
index c1e47bf5632..10f1e561fc3 100644
--- a/mozilla/layout/forms/nsSelectsAreaFrame.h
+++ b/mozilla/layout/forms/nsSelectsAreaFrame.h
@@ -54,7 +54,7 @@ public:
   // nsISupports
   //NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
   
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
 
   NS_IMETHOD Paint(nsPresContext*      aPresContext,
                    nsIRenderingContext& aRenderingContext,
diff --git a/mozilla/layout/forms/nsTextControlFrame.cpp b/mozilla/layout/forms/nsTextControlFrame.cpp
index cfc88e817df..830672ae952 100644
--- a/mozilla/layout/forms/nsTextControlFrame.cpp
+++ b/mozilla/layout/forms/nsTextControlFrame.cpp
@@ -2080,22 +2080,21 @@ nsTextControlFrame::Paint(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsTextControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                         const nsPoint& aPoint,
+nsTextControlFrame::GetFrameForPoint(const nsPoint& aPoint,
                                          nsFramePaintLayer aWhichLayer,
                                          nsIFrame** aFrame)
 {
   nsresult rv = NS_ERROR_FAILURE;
   if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
-    rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsStackFrame::GetFrameForPoint(aPoint,
                                       NS_FRAME_PAINT_LAYER_FOREGROUND, aFrame);
     if (NS_SUCCEEDED(rv))
       return NS_OK;
-    rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsStackFrame::GetFrameForPoint(aPoint,
                                         NS_FRAME_PAINT_LAYER_FLOATS, aFrame);
     if (NS_SUCCEEDED(rv))
       return NS_OK;
-    rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
+    rv = nsStackFrame::GetFrameForPoint(aPoint,
                                       NS_FRAME_PAINT_LAYER_BACKGROUND, aFrame);
   }
   return rv;
diff --git a/mozilla/layout/forms/nsTextControlFrame.h b/mozilla/layout/forms/nsTextControlFrame.h
index 1933fb101e2..cddff25d91d 100644
--- a/mozilla/layout/forms/nsTextControlFrame.h
+++ b/mozilla/layout/forms/nsTextControlFrame.h
@@ -91,8 +91,7 @@ public:
                     nsFramePaintLayer    aWhichLayer,
                     PRUint32             aFlags = 0);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame** aFrame);
 
diff --git a/mozilla/layout/generic/nsBlockFrame.cpp b/mozilla/layout/generic/nsBlockFrame.cpp
index 47190075512..7e599b13a9e 100644
--- a/mozilla/layout/generic/nsBlockFrame.cpp
+++ b/mozilla/layout/generic/nsBlockFrame.cpp
@@ -6386,14 +6386,14 @@ nsLineBox* nsBlockFrame::GetFirstLineContaining(nscoord y) {
 
 static inline void
 GetFrameFromLine(const nsRect& aLineArea, const nsPoint& aTmp,
-                 nsBlockFrame::line_iterator& aLine, nsPresContext* aPresContext,
+                 nsBlockFrame::line_iterator& aLine,
                  nsFramePaintLayer aWhichLayer, nsIFrame** aFrame) {
   if (aLineArea.Contains(aTmp)) {
     nsIFrame* kid = aLine->mFirstChild;
     PRInt32 n = aLine->GetChildCount();
     while (--n >= 0) {
       nsIFrame *hit;
-      nsresult rv = kid->GetFrameForPoint(aPresContext, aTmp, aWhichLayer, &hit);
+      nsresult rv = kid->GetFrameForPoint(aTmp, aWhichLayer, &hit);
       
       if (NS_SUCCEEDED(rv) && hit) {
         *aFrame = hit;
@@ -6406,16 +6406,15 @@ GetFrameFromLine(const nsRect& aLineArea, const nsPoint& aTmp,
 // Optimized function that uses line combined areas to skip lines
 // we know can't contain the point
 nsresult
-nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
-                                    const nsPoint& aPoint,
+nsBlockFrame::GetFrameForPointUsing(const nsPoint& aPoint,
                                     nsIAtom*       aList,
                                     nsFramePaintLayer aWhichLayer,
                                     PRBool         aConsiderSelf,
                                     nsIFrame**     aFrame)
 {
   if (aList) {
-    return nsContainerFrame::GetFrameForPointUsing(aPresContext,
-      aPoint, aList, aWhichLayer, aConsiderSelf, aFrame);
+    return nsContainerFrame::GetFrameForPointUsing(aPoint,
+      aList, aWhichLayer, aConsiderSelf, aFrame);
   }
 
   PRBool inThisFrame = mRect.Contains(aPoint);
@@ -6429,7 +6428,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
 
   nsPoint originOffset;
   nsIView *view = nsnull;
-  nsresult rv = GetOriginToViewOffset(aPresContext, originOffset, &view);
+  nsresult rv = GetOriginToViewOffset(originOffset, &view);
 
   if (NS_SUCCEEDED(rv) && view)
     tmp += originOffset;
@@ -6449,7 +6448,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
         if (lineArea.y > tmp.y) {
           break;
         }
-        GetFrameFromLine(lineArea, tmp, line, aPresContext, aWhichLayer, aFrame);
+        GetFrameFromLine(lineArea, tmp, line, aWhichLayer, aFrame);
       }
     }
   } else {
@@ -6469,7 +6468,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
         lastY = lineArea.y;
         lastYMost = lineArea.YMost();
 
-        GetFrameFromLine(lineArea, tmp, line, aPresContext, aWhichLayer, aFrame);
+        GetFrameFromLine(lineArea, tmp, line, aWhichLayer, aFrame);
       }
       lineCount++;
     }
@@ -6494,8 +6493,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP
-nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                               const nsPoint& aPoint,
+nsBlockFrame::GetFrameForPoint(const nsPoint& aPoint,
                                nsFramePaintLayer aWhichLayer,
                                nsIFrame** aFrame)
 {
@@ -6503,12 +6501,16 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
 
   switch (aWhichLayer) {
     case NS_FRAME_PAINT_LAYER_FOREGROUND:
-      rv = GetFrameForPointUsing(aPresContext, aPoint, nsnull, NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE, aFrame);
+      rv = GetFrameForPointUsing(aPoint, nsnull,
+                                 NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE,
+                                 aFrame);
       if (NS_OK == rv) {
         return NS_OK;
       }
       if (nsnull != mBullet) {
-        rv = GetFrameForPointUsing(aPresContext, aPoint, nsLayoutAtoms::bulletList, NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE, aFrame);
+        rv = GetFrameForPointUsing(aPoint, nsLayoutAtoms::bulletList,
+                                   NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE,
+                                   aFrame);
       }
       return rv;
       break;
@@ -6516,16 +6518,16 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
     case NS_FRAME_PAINT_LAYER_FLOATS:
       // we painted our floats before our children, and thus
       // we should check floats within children first
-      rv = GetFrameForPointUsing(aPresContext, aPoint, nsnull, NS_FRAME_PAINT_LAYER_FLOATS, PR_FALSE, aFrame);
+      rv = GetFrameForPointUsing(aPoint, nsnull,
+                                 NS_FRAME_PAINT_LAYER_FLOATS, PR_FALSE,
+                                 aFrame);
       if (NS_OK == rv) {
         return NS_OK;
       }
       if (mFloats.NotEmpty()) {
-
-        return GetFrameForPointUsing(aPresContext, aPoint,
-                                     nsLayoutAtoms::floatList,
-                                     NS_FRAME_PAINT_LAYER_ALL,
-                                     PR_FALSE, aFrame);
+        return GetFrameForPointUsing(aPoint, nsLayoutAtoms::floatList,
+                                     NS_FRAME_PAINT_LAYER_ALL, PR_FALSE,
+                                     aFrame);
       } else {
         return NS_ERROR_FAILURE;
       }
@@ -6533,9 +6535,9 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
 
     case NS_FRAME_PAINT_LAYER_BACKGROUND:
       // we're a block, so PR_TRUE for consider self
-      return GetFrameForPointUsing(aPresContext, aPoint, nsnull,
-                                   NS_FRAME_PAINT_LAYER_BACKGROUND,
-                                   PR_TRUE, aFrame);
+      return GetFrameForPointUsing(aPoint, nsnull,
+                                   NS_FRAME_PAINT_LAYER_BACKGROUND, PR_TRUE,
+                                   aFrame);
       break;
   }
   // we shouldn't get here
diff --git a/mozilla/layout/generic/nsBlockFrame.h b/mozilla/layout/generic/nsBlockFrame.h
index 349d44c86db..7a8f018aa99 100644
--- a/mozilla/layout/generic/nsBlockFrame.h
+++ b/mozilla/layout/generic/nsBlockFrame.h
@@ -179,13 +179,12 @@ public:
   // are non-decreasing.
   void SetupLineCursor();
 
-  nsresult GetFrameForPointUsing(nsPresContext* aPresContext,
-                                 const nsPoint& aPoint,
+  nsresult GetFrameForPointUsing(const nsPoint& aPoint,
                                  nsIAtom*       aList,
                                  nsFramePaintLayer aWhichLayer,
                                  PRBool         aConsiderSelf,
                                  nsIFrame**     aFrame);
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
   NS_IMETHOD HandleEvent(nsPresContext* aPresContext, 
                          nsGUIEvent*     aEvent,
                          nsEventStatus*  aEventStatus);
diff --git a/mozilla/layout/generic/nsContainerFrame.cpp b/mozilla/layout/generic/nsContainerFrame.cpp
index b7631c489e4..0b29f6ce556 100644
--- a/mozilla/layout/generic/nsContainerFrame.cpp
+++ b/mozilla/layout/generic/nsContainerFrame.cpp
@@ -317,17 +317,15 @@ nsContainerFrame::PaintChild(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsContainerFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsContainerFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND), aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND), aFrame);
 }
 
 nsresult
-nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
-                                        const nsPoint& aPoint,
+nsContainerFrame::GetFrameForPointUsing(const nsPoint& aPoint,
                                         nsIAtom*       aList,
                                         nsFramePaintLayer aWhichLayer,
                                         PRBool         aConsiderSelf,
@@ -348,7 +346,7 @@ nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
 
   nsPoint originOffset;
   nsIView *view = nsnull;
-  nsresult rv = GetOriginToViewOffset(aPresContext, originOffset, &view);
+  nsresult rv = GetOriginToViewOffset(originOffset, &view);
 
   if (NS_SUCCEEDED(rv) && view)
     tmp += originOffset;
@@ -356,18 +354,15 @@ nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
   while (kid) {
     if (aWhichLayer == NS_FRAME_PAINT_LAYER_ALL) {
       // Check all layers on this kid before moving on to the next one
-      rv = kid->GetFrameForPoint(aPresContext, tmp,
-                                 NS_FRAME_PAINT_LAYER_FOREGROUND, &hit);
+      rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_FOREGROUND, &hit);
       if (NS_FAILED(rv) || !hit) {
-        rv = kid->GetFrameForPoint(aPresContext, tmp,
-                                   NS_FRAME_PAINT_LAYER_FLOATS, &hit);
+        rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_FLOATS, &hit);
         if (NS_FAILED(rv) || !hit) {
-          rv = kid->GetFrameForPoint(aPresContext, tmp,
-                                     NS_FRAME_PAINT_LAYER_BACKGROUND, &hit);
+          rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_BACKGROUND, &hit);
         }
       }
     } else {
-      rv = kid->GetFrameForPoint(aPresContext, tmp, aWhichLayer, &hit);
+      rv = kid->GetFrameForPoint(tmp, aWhichLayer, &hit);
     }
 
     if (NS_SUCCEEDED(rv) && hit) {
diff --git a/mozilla/layout/generic/nsContainerFrame.h b/mozilla/layout/generic/nsContainerFrame.h
index 1fe99f7e0cd..5847fd38273 100644
--- a/mozilla/layout/generic/nsContainerFrame.h
+++ b/mozilla/layout/generic/nsContainerFrame.h
@@ -70,8 +70,7 @@ public:
                    const nsRect&        aDirtyRect,
                    nsFramePaintLayer    aWhichLayer,
                    PRUint32             aFlags = 0);
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
   NS_IMETHOD ReplaceFrame(nsPresContext* aPresContext,
@@ -188,8 +187,7 @@ protected:
   nsContainerFrame();
   ~nsContainerFrame();
 
-  nsresult GetFrameForPointUsing(nsPresContext* aPresContext,
-                                 const nsPoint& aPoint,
+  nsresult GetFrameForPointUsing(const nsPoint& aPoint,
                                  nsIAtom*       aList,
                                  nsFramePaintLayer aWhichLayer,
                                  PRBool         aConsiderSelf,
diff --git a/mozilla/layout/generic/nsFrame.cpp b/mozilla/layout/generic/nsFrame.cpp
index 0d50a4c1f54..c79d3a55afb 100644
--- a/mozilla/layout/generic/nsFrame.cpp
+++ b/mozilla/layout/generic/nsFrame.cpp
@@ -2041,8 +2041,7 @@ nsFrame::GetCursor(const nsPoint& aPoint,
 }
 
 NS_IMETHODIMP
-nsFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                          const nsPoint& aPoint,
+nsFrame::GetFrameForPoint(const nsPoint& aPoint,
                           nsFramePaintLayer aWhichLayer,
                           nsIFrame** aFrame)
 {
@@ -2368,11 +2367,9 @@ NS_IMETHODIMP nsFrame::GetOffsetFromView(nsPoint&  aOffset,
 // not a descendant of the frame's parent view (ex: scrolling popup menu),
 // the offset returned will be (0,0).
 
-NS_IMETHODIMP nsFrame::GetOriginToViewOffset(nsPresContext* aPresContext,
-                                             nsPoint&        aOffset,
+NS_IMETHODIMP nsFrame::GetOriginToViewOffset(nsPoint&        aOffset,
                                              nsIView**       aView) const
 {
-  NS_ENSURE_ARG_POINTER(aPresContext);
   nsresult rv = NS_OK;
 
   aOffset.MoveTo(0,0);
diff --git a/mozilla/layout/generic/nsFrame.h b/mozilla/layout/generic/nsFrame.h
index ed745863571..ea3477dbf2f 100644
--- a/mozilla/layout/generic/nsFrame.h
+++ b/mozilla/layout/generic/nsFrame.h
@@ -208,8 +208,7 @@ public:
                                  nsIContent** aContent);
   NS_IMETHOD  GetCursor(const nsPoint&    aPoint,
                         nsIFrame::Cursor& aCursor);
-  NS_IMETHOD  GetFrameForPoint(nsPresContext* aPresContext,
-                               const nsPoint& aPoint, 
+  NS_IMETHOD  GetFrameForPoint(const nsPoint& aPoint, 
                                nsFramePaintLayer aWhichLayer,
                                nsIFrame**     aFrame);
 
@@ -242,7 +241,7 @@ public:
   virtual nsIFrame* GetNextInFlow() const;
   NS_IMETHOD  SetNextInFlow(nsIFrame*);
   NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsIView** aView) const;
-  NS_IMETHOD  GetOriginToViewOffset(nsPresContext *aPresContext, nsPoint& aOffset, nsIView **aView) const;
+  NS_IMETHOD  GetOriginToViewOffset(nsPoint& aOffset, nsIView **aView) const;
   virtual nsIAtom* GetType() const;
   virtual PRBool IsContainingBlock() const;
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/generic/nsFrameSetFrame.cpp b/mozilla/layout/generic/nsFrameSetFrame.cpp
index dc259060803..54f2b304241 100644
--- a/mozilla/layout/generic/nsFrameSetFrame.cpp
+++ b/mozilla/layout/generic/nsFrameSetFrame.cpp
@@ -134,8 +134,7 @@ public:
                          nsGUIEvent* aEvent,
                          nsEventStatus* aEventStatus);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
@@ -842,8 +841,7 @@ nsHTMLFramesetFrame::GetCursor(const nsPoint&    aPoint,
 }
 
 NS_IMETHODIMP 
-nsHTMLFramesetFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                      const nsPoint& aPoint, 
+nsHTMLFramesetFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                       nsFramePaintLayer aWhichLayer,
                                       nsIFrame**     aFrame)
 {
@@ -852,7 +850,7 @@ nsHTMLFramesetFrame::GetFrameForPoint(nsPresContext* aPresContext,
     *aFrame = this;
     return NS_OK;
   } else {
-    return nsContainerFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+    return nsContainerFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
   }
 }
 
@@ -1762,8 +1760,7 @@ nsHTMLFramesetBorderFrame::HandleEvent(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP 
-nsHTMLFramesetBorderFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                            const nsPoint& aPoint, 
+nsHTMLFramesetBorderFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                             nsFramePaintLayer aWhichLayer,
                                             nsIFrame**     aFrame)
 {
diff --git a/mozilla/layout/generic/nsFrameSetFrame.h b/mozilla/layout/generic/nsFrameSetFrame.h
index 1ac7afa5c27..92b438044ba 100644
--- a/mozilla/layout/generic/nsFrameSetFrame.h
+++ b/mozilla/layout/generic/nsFrameSetFrame.h
@@ -135,8 +135,7 @@ public:
                          nsGUIEvent*     aEvent,
                          nsEventStatus*  aEventStatus);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/generic/nsHTMLFrame.cpp b/mozilla/layout/generic/nsHTMLFrame.cpp
index d74adbf2286..bfc46cc21b2 100644
--- a/mozilla/layout/generic/nsHTMLFrame.cpp
+++ b/mozilla/layout/generic/nsHTMLFrame.cpp
@@ -118,8 +118,7 @@ public:
   NS_IMETHOD HandleEvent(nsPresContext* aPresContext, 
                          nsGUIEvent*     aEvent,
                          nsEventStatus*  aEventStatus);
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
   virtual PRBool IsContainingBlock() const { return PR_TRUE; }
@@ -630,13 +629,12 @@ CanvasFrame::HandleEvent(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP
-CanvasFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+CanvasFrame::GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
 }
 
 nsIAtom*
diff --git a/mozilla/layout/generic/nsIFrame.h b/mozilla/layout/generic/nsIFrame.h
index ba13599d4cb..9ea8fc97fd5 100644
--- a/mozilla/layout/generic/nsIFrame.h
+++ b/mozilla/layout/generic/nsIFrame.h
@@ -769,8 +769,7 @@ public:
    * recieve the events.  A successful return value indicates that a
    * point was found.
    */
-  NS_IMETHOD  GetFrameForPoint(nsPresContext* aPresContext,
-                               const nsPoint& aPoint, 
+  NS_IMETHOD  GetFrameForPoint(const nsPoint& aPoint, 
                                nsFramePaintLayer aWhichLayer,
                                nsIFrame**     aFrame) = 0;
   
@@ -1029,8 +1028,7 @@ public:
    * aView is optional, that is, you may pass null if you are not interested
    * in getting a pointer to the view.
    */
-  NS_IMETHOD  GetOriginToViewOffset(nsPresContext* aPresContext,
-                                    nsPoint&        aOffset,
+  NS_IMETHOD  GetOriginToViewOffset(nsPoint&        aOffset,
                                     nsIView**       aView) const = 0;
 
   /**
diff --git a/mozilla/layout/generic/nsViewportFrame.cpp b/mozilla/layout/generic/nsViewportFrame.cpp
index c2538916a2f..cd8aa00978a 100644
--- a/mozilla/layout/generic/nsViewportFrame.cpp
+++ b/mozilla/layout/generic/nsViewportFrame.cpp
@@ -89,13 +89,12 @@ ViewportFrame::SetInitialChildList(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP
-ViewportFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+ViewportFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, 
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, 
                                (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
 }
 
diff --git a/mozilla/layout/generic/nsViewportFrame.h b/mozilla/layout/generic/nsViewportFrame.h
index aef1c0bb6c9..c3e68db0aa7 100644
--- a/mozilla/layout/generic/nsViewportFrame.h
+++ b/mozilla/layout/generic/nsViewportFrame.h
@@ -71,8 +71,7 @@ public:
                                  nsIAtom*        aListName,
                                  nsIFrame*       aChildList);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext*   aPresContext,
-                              const nsPoint&    aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint&    aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**        aFrame);
 
diff --git a/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.cpp b/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.cpp
index 271d71bce15..ce54e497397 100644
--- a/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.cpp
+++ b/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.cpp
@@ -254,17 +254,16 @@ nsMathMLmactionFrame::SetInitialChildList(nsPresContext* aPresContext,
 
 // Return the selected frame ...
 NS_IMETHODIMP
-nsMathMLmactionFrame::GetFrameForPoint(nsPresContext*   aPresContext,
-                                       const nsPoint&    aPoint,
+nsMathMLmactionFrame::GetFrameForPoint(const nsPoint&    aPoint,
                                        nsFramePaintLayer aWhichLayer,
                                        nsIFrame**        aFrame)
 {
   nsIFrame* childFrame = GetSelectedFrame();
   if (childFrame) {
     nsPoint pt(aPoint.x - mRect.x, aPoint.y - mRect.y);
-    return childFrame->GetFrameForPoint(aPresContext, pt, aWhichLayer, aFrame);
+    return childFrame->GetFrameForPoint(pt, aWhichLayer, aFrame);
   }
-  return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 //  Only paint the selected child...
diff --git a/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.h b/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.h
index 372b28b04b6..53175dc6185 100644
--- a/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.h
+++ b/mozilla/layout/mathml/base/src/nsMathMLmactionFrame.h
@@ -73,8 +73,7 @@ public:
                       nsIFrame*       aChildList);
 
   NS_IMETHOD
-  GetFrameForPoint(nsPresContext*   aPresContext,
-                   const nsPoint&    aPoint,
+  GetFrameForPoint(const nsPoint&    aPoint,
                    nsFramePaintLayer aWhichLayer,
                    nsIFrame**        aFrame);
 
diff --git a/mozilla/layout/svg/base/src/nsSVGForeignObjectFrame.cpp b/mozilla/layout/svg/base/src/nsSVGForeignObjectFrame.cpp
index deebe315976..1e361eed758 100644
--- a/mozilla/layout/svg/base/src/nsSVGForeignObjectFrame.cpp
+++ b/mozilla/layout/svg/base/src/nsSVGForeignObjectFrame.cpp
@@ -524,23 +524,24 @@ nsSVGForeignObjectFrame::GetFrameForPoint(float x, float y, nsIFrame** hit)
 {
   *hit = nsnull;
 
-  nsPresContext *presContext = GetPresContext();
-
   nsPoint p( (nscoord)(x*GetTwipsPerPx()),
              (nscoord)(y*GetTwipsPerPx()));
 
   nsresult rv;
 
-  rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
-                                                     NS_FRAME_PAINT_LAYER_FOREGROUND, hit);
+  rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
+                                               NS_FRAME_PAINT_LAYER_FOREGROUND,
+                                               hit);
   if (NS_SUCCEEDED(rv) && *hit) return rv;
 
-  rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
-                                                     NS_FRAME_PAINT_LAYER_FLOATS, hit);
+  rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
+                                               NS_FRAME_PAINT_LAYER_FLOATS,
+                                               hit);
   if (NS_SUCCEEDED(rv) && *hit) return rv;
 
-  return nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
-                                                       NS_FRAME_PAINT_LAYER_BACKGROUND, hit);
+  return nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
+                                               NS_FRAME_PAINT_LAYER_BACKGROUND,
+                                               hit);
 }
 
 NS_IMETHODIMP_(already_AddRefed<nsISVGRendererRegion>)
diff --git a/mozilla/layout/svg/base/src/nsSVGOuterSVGFrame.cpp b/mozilla/layout/svg/base/src/nsSVGOuterSVGFrame.cpp
index c9c5d2a6d4f..ed6f88fbf39 100644
--- a/mozilla/layout/svg/base/src/nsSVGOuterSVGFrame.cpp
+++ b/mozilla/layout/svg/base/src/nsSVGOuterSVGFrame.cpp
@@ -210,8 +210,7 @@ public:
                                nsIAtom*        aAttribute,
                                PRInt32         aModType);
 
-  NS_IMETHOD  GetFrameForPoint(nsPresContext* aPresContext,
-                               const nsPoint& aPoint, 
+  NS_IMETHOD  GetFrameForPoint(const nsPoint& aPoint, 
                                nsFramePaintLayer aWhichLayer,
                                nsIFrame**     aFrame);
 
@@ -709,8 +708,7 @@ nsSVGOuterSVGFrame::AttributeChanged(nsIContent*     aChild,
 
 
 nsresult
-nsSVGOuterSVGFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint,
+nsSVGOuterSVGFrame::GetFrameForPoint(const nsPoint& aPoint,
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame**     aFrame)
 {
diff --git a/mozilla/layout/tables/nsTableCellFrame.cpp b/mozilla/layout/tables/nsTableCellFrame.cpp
index cdee43fc589..7265ba38e7f 100644
--- a/mozilla/layout/tables/nsTableCellFrame.cpp
+++ b/mozilla/layout/tables/nsTableCellFrame.cpp
@@ -461,13 +461,12 @@ nsTableCellFrame::Paint(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsTableCellFrame::GetFrameForPoint(nsPresContext*   aPresContext,
-                                   const nsPoint&    aPoint, 
+nsTableCellFrame::GetFrameForPoint(const nsPoint&    aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**        aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
 }
 
 //null range means the whole thing
diff --git a/mozilla/layout/tables/nsTableCellFrame.h b/mozilla/layout/tables/nsTableCellFrame.h
index 1211ef15979..9232b39628a 100644
--- a/mozilla/layout/tables/nsTableCellFrame.h
+++ b/mozilla/layout/tables/nsTableCellFrame.h
@@ -137,8 +137,7 @@ public:
                    nsFramePaintLayer    aWhichLayer,
                    PRUint32             aFlags = 0);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/tables/nsTableColFrame.cpp b/mozilla/layout/tables/nsTableColFrame.cpp
index 64893fe4202..0cb2b1d595f 100644
--- a/mozilla/layout/tables/nsTableColFrame.cpp
+++ b/mozilla/layout/tables/nsTableColFrame.cpp
@@ -145,8 +145,7 @@ nsTableColFrame::Paint(nsPresContext*      aPresContext,
 
 // override, since we want to act like a block
 NS_IMETHODIMP
-nsTableColFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                          const nsPoint& aPoint,
+nsTableColFrame::GetFrameForPoint(const nsPoint& aPoint,
                           nsFramePaintLayer aWhichLayer,
                           nsIFrame** aFrame)
 {
diff --git a/mozilla/layout/tables/nsTableColFrame.h b/mozilla/layout/tables/nsTableColFrame.h
index d708084c758..3b60f75ccac 100644
--- a/mozilla/layout/tables/nsTableColFrame.h
+++ b/mozilla/layout/tables/nsTableColFrame.h
@@ -120,8 +120,7 @@ public:
   // column groups don't paint their own background -- the cells do
   virtual PRBool CanPaintBackground() { return PR_FALSE; }
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/tables/nsTableColGroupFrame.cpp b/mozilla/layout/tables/nsTableColGroupFrame.cpp
index e86844781b7..d4c71ff6f85 100644
--- a/mozilla/layout/tables/nsTableColGroupFrame.cpp
+++ b/mozilla/layout/tables/nsTableColGroupFrame.cpp
@@ -342,13 +342,12 @@ nsTableColGroupFrame::GetSkipSides() const
 }
 
 NS_IMETHODIMP
-nsTableColGroupFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsTableColGroupFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
 }
 
 NS_METHOD nsTableColGroupFrame::Reflow(nsPresContext*          aPresContext,
diff --git a/mozilla/layout/tables/nsTableColGroupFrame.h b/mozilla/layout/tables/nsTableColGroupFrame.h
index d26e02ee3fb..6f28263cd8b 100644
--- a/mozilla/layout/tables/nsTableColGroupFrame.h
+++ b/mozilla/layout/tables/nsTableColGroupFrame.h
@@ -155,8 +155,7 @@ public:
 
   /** @see nsIFrame::GetFrameForPoint
     */
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/tables/nsTableFrame.cpp b/mozilla/layout/tables/nsTableFrame.cpp
index 8f2c4051d1f..09d4080133a 100644
--- a/mozilla/layout/tables/nsTableFrame.cpp
+++ b/mozilla/layout/tables/nsTableFrame.cpp
@@ -1457,13 +1457,12 @@ nsTableFrame::Paint(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsTableFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsTableFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
 }
 
 
diff --git a/mozilla/layout/tables/nsTableFrame.h b/mozilla/layout/tables/nsTableFrame.h
index 1bde58f3595..d2d6cfeb61e 100644
--- a/mozilla/layout/tables/nsTableFrame.h
+++ b/mozilla/layout/tables/nsTableFrame.h
@@ -341,8 +341,7 @@ public:
                       nsIRenderingContext& aRenderingContext,
                       const nsRect&        aDirtyRect);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/tables/nsTableOuterFrame.cpp b/mozilla/layout/tables/nsTableOuterFrame.cpp
index 57abcf45b40..fd646b3f024 100644
--- a/mozilla/layout/tables/nsTableOuterFrame.cpp
+++ b/mozilla/layout/tables/nsTableOuterFrame.cpp
@@ -353,8 +353,7 @@ nsTableOuterFrame::Paint(nsPresContext*      aPresContext,
 }
 
 NS_IMETHODIMP
-nsTableOuterFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsTableOuterFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
@@ -362,14 +361,14 @@ nsTableOuterFrame::GetFrameForPoint(nsPresContext* aPresContext,
   
   // caption frames live in a different list which we need to check separately
   if (mCaptionFrame) {
-    rv = GetFrameForPointUsing(aPresContext, aPoint, nsLayoutAtoms::captionList, aWhichLayer, PR_FALSE, aFrame);
+    rv = GetFrameForPointUsing(aPoint, nsLayoutAtoms::captionList, aWhichLayer, PR_FALSE, aFrame);
     if (NS_OK == rv) {
       return NS_OK;
     }
   }
   // This frame should never get events (it contains the margins of the
   // table), so always pass |PR_FALSE| for |aConsiderSelf|.
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
 }
 
 NS_IMETHODIMP nsTableOuterFrame::SetSelected(nsPresContext* aPresContext,
diff --git a/mozilla/layout/tables/nsTableOuterFrame.h b/mozilla/layout/tables/nsTableOuterFrame.h
index 9cc0b21fb8c..49bec561eb7 100644
--- a/mozilla/layout/tables/nsTableOuterFrame.h
+++ b/mozilla/layout/tables/nsTableOuterFrame.h
@@ -140,8 +140,7 @@ public:
   // the outer table does not paint its entire background if it has margins and/or captions
   virtual PRBool CanPaintBackground() { return PR_FALSE; }
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/tables/nsTableRowFrame.cpp b/mozilla/layout/tables/nsTableRowFrame.cpp
index 3ad0ad99505..827249f48a7 100644
--- a/mozilla/layout/tables/nsTableRowFrame.cpp
+++ b/mozilla/layout/tables/nsTableRowFrame.cpp
@@ -595,8 +595,7 @@ nsTableRowFrame::GetSkipSides() const
  * sufficient.  We have to ask the row if it has a child that contains the point.
  */
 NS_IMETHODIMP
-nsTableRowFrame::GetFrameForPoint(nsPresContext*        aPresContext,
-                                       const nsPoint&    aPoint,
+nsTableRowFrame::GetFrameForPoint(const nsPoint&    aPoint,
                                        nsFramePaintLayer aWhichLayer,
                                        nsIFrame**        aFrame)
 {
@@ -620,7 +619,7 @@ nsTableRowFrame::GetFrameForPoint(nsPresContext*        aPresContext,
   *aFrame = nsnull;
   tmp.MoveTo(aPoint.x - mRect.x, aPoint.y - mRect.y);
   while (nsnull != kid) {
-    nsresult rv = kid->GetFrameForPoint(aPresContext, tmp, aWhichLayer, &hit);
+    nsresult rv = kid->GetFrameForPoint(tmp, aWhichLayer, &hit);
 
     if (NS_SUCCEEDED(rv) && hit) {
       *aFrame = hit;
diff --git a/mozilla/layout/tables/nsTableRowFrame.h b/mozilla/layout/tables/nsTableRowFrame.h
index 2a5a5559766..484e7b86816 100644
--- a/mozilla/layout/tables/nsTableRowFrame.h
+++ b/mozilla/layout/tables/nsTableRowFrame.h
@@ -107,8 +107,7 @@ public:
   // rows don't paint their own background -- the cells do
   virtual PRBool CanPaintBackground() { return PR_FALSE; }
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext*   aPresContext,
-                              const nsPoint&    aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint&    aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**        aFrame);
 
diff --git a/mozilla/layout/tables/nsTableRowGroupFrame.cpp b/mozilla/layout/tables/nsTableRowGroupFrame.cpp
index 08ef2029a51..2f4d3202578 100644
--- a/mozilla/layout/tables/nsTableRowGroupFrame.cpp
+++ b/mozilla/layout/tables/nsTableRowGroupFrame.cpp
@@ -248,13 +248,12 @@ nsTableRowGroupFrame::GetSkipSides() const
 
 
 NS_IMETHODIMP
-nsTableRowGroupFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsTableRowGroupFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
+  return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
 }
 
 // Position and size aKidFrame and update our reflow state. The origin of
diff --git a/mozilla/layout/tables/nsTableRowGroupFrame.h b/mozilla/layout/tables/nsTableRowGroupFrame.h
index 94316436a54..39a3ea7952e 100644
--- a/mozilla/layout/tables/nsTableRowGroupFrame.h
+++ b/mozilla/layout/tables/nsTableRowGroupFrame.h
@@ -152,7 +152,7 @@ public:
    * Return PR_TRUE if a frame containing the point is found.
    * @see nsContainerFrame::GetFrameForPoint
    */
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
 
    /** calls Reflow for all of its child rows.
     * Rows are all set to the same width and stacked vertically.
diff --git a/mozilla/layout/xul/base/src/nsBoxFrame.cpp b/mozilla/layout/xul/base/src/nsBoxFrame.cpp
index 875c3478418..1dab3d4bace 100644
--- a/mozilla/layout/xul/base/src/nsBoxFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsBoxFrame.cpp
@@ -1738,8 +1738,7 @@ nsBoxFrame::GetDebug(PRBool& aDebug)
 #endif
 
 NS_IMETHODIMP  
-nsBoxFrame::GetFrameForPoint(nsPresContext*   aPresContext,
-                             const nsPoint&    aPoint, 
+nsBoxFrame::GetFrameForPoint(const nsPoint&    aPoint, 
                              nsFramePaintLayer aWhichLayer,    
                              nsIFrame**        aFrame)
 {   
@@ -1752,7 +1751,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext*   aPresContext,
 
   nsIView* view = nsnull;
   nsPoint originOffset;
-  GetOriginToViewOffset(aPresContext, originOffset, &view);
+  GetOriginToViewOffset(originOffset, &view);
 
 #ifdef DEBUG_LAYOUT
   // get the debug frame.
@@ -1783,7 +1782,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext*   aPresContext,
   nsIBox* kid = nsnull;
   GetChildBox(&kid);
   while (nsnull != kid) {
-    GetFrameForPointChild(aPresContext, tmp, aWhichLayer, kid, hit != nsnull, &hit);
+    GetFrameForPointChild(tmp, aWhichLayer, kid, hit != nsnull, &hit);
     kid->GetNextBox(&kid);
   }
   if (hit)
@@ -1803,8 +1802,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext*   aPresContext,
 }
 
 /* virtual */ nsresult
-nsBoxFrame::GetFrameForPointChild(nsPresContext*   aPresContext,
-                                  const nsPoint&    aPoint,
+nsBoxFrame::GetFrameForPointChild(const nsPoint&    aPoint,
                                   nsFramePaintLayer aWhichLayer,    
                                   nsIFrame*         aChild,
                                   PRBool            aCheckMouseThrough,
@@ -1812,7 +1810,7 @@ nsBoxFrame::GetFrameForPointChild(nsPresContext*   aPresContext,
 {
   nsIFrame *hit = nsnull;
   nsresult rv =
-    aChild->GetFrameForPoint(aPresContext, aPoint, aWhichLayer, &hit);
+    aChild->GetFrameForPoint(aPoint, aWhichLayer, &hit);
 
   if (NS_SUCCEEDED(rv) && hit) {
     rv = NS_ERROR_FAILURE;
diff --git a/mozilla/layout/xul/base/src/nsBoxFrame.h b/mozilla/layout/xul/base/src/nsBoxFrame.h
index ee804b4f461..6002d969d2a 100644
--- a/mozilla/layout/xul/base/src/nsBoxFrame.h
+++ b/mozilla/layout/xul/base/src/nsBoxFrame.h
@@ -123,8 +123,7 @@ public:
 
   // ----- public methods -------
   
-  NS_IMETHOD GetFrameForPoint(nsPresContext*   aPresContext,
-                              const nsPoint&    aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint&    aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**        aFrame);
 
@@ -258,8 +257,7 @@ protected:
     nsresult RegUnregAccessKey(nsPresContext* aPresContext,
                                PRBool aDoReg);
     void FireDOMEvent(nsPresContext *aPresContext, const nsAString& aDOMEventName);
-    virtual nsresult GetFrameForPointChild(nsPresContext*   aPresContext,
-                                           const nsPoint&    aPoint,
+    virtual nsresult GetFrameForPointChild(const nsPoint&    aPoint,
                                            nsFramePaintLayer aWhichLayer,    
                                            nsIFrame*         aChild,
                                            PRBool            aCheckMouseThrough,
diff --git a/mozilla/layout/xul/base/src/nsButtonBoxFrame.cpp b/mozilla/layout/xul/base/src/nsButtonBoxFrame.cpp
index 77255c13593..8f0bbeb6392 100644
--- a/mozilla/layout/xul/base/src/nsButtonBoxFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsButtonBoxFrame.cpp
@@ -86,13 +86,12 @@ nsButtonBoxFrame::GetMouseThrough(PRBool& aMouseThrough)
   return NS_OK;
 }
 
-NS_IMETHODIMP nsButtonBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                    const nsPoint& aPoint, 
+NS_IMETHODIMP nsButtonBoxFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                     nsFramePaintLayer aWhichLayer,
                                     nsIFrame**     aFrame)
 {
   // override, since we don't want children to get events
-  return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 NS_IMETHODIMP
diff --git a/mozilla/layout/xul/base/src/nsButtonBoxFrame.h b/mozilla/layout/xul/base/src/nsButtonBoxFrame.h
index 4c561ba63e1..7ac253889c5 100644
--- a/mozilla/layout/xul/base/src/nsButtonBoxFrame.h
+++ b/mozilla/layout/xul/base/src/nsButtonBoxFrame.h
@@ -47,8 +47,7 @@ public:
 
   nsButtonBoxFrame(nsIPresShell* aPresShell);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsDeckFrame.cpp b/mozilla/layout/xul/base/src/nsDeckFrame.cpp
index 3eb38001124..faac6356adf 100644
--- a/mozilla/layout/xul/base/src/nsDeckFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsDeckFrame.cpp
@@ -241,8 +241,7 @@ nsDeckFrame::Paint(nsPresContext*      aPresContext,
 
 
 NS_IMETHODIMP
-nsDeckFrame::GetFrameForPoint(nsPresContext*   aPresContext,
-                              const nsPoint&    aPoint, 
+nsDeckFrame::GetFrameForPoint(const nsPoint&    aPoint, 
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**        aFrame)
 {
@@ -256,8 +255,7 @@ nsDeckFrame::GetFrameForPoint(nsPresContext*   aPresContext,
   if (selectedBox) {
     nsPoint tmp(aPoint.x - mRect.x, aPoint.y - mRect.y);
 
-    if (NS_SUCCEEDED(selectedBox->GetFrameForPoint(aPresContext, tmp,
-                                                   aWhichLayer, aFrame)))
+    if (NS_SUCCEEDED(selectedBox->GetFrameForPoint(tmp, aWhichLayer, aFrame)))
       return NS_OK;
   }
     
diff --git a/mozilla/layout/xul/base/src/nsDeckFrame.h b/mozilla/layout/xul/base/src/nsDeckFrame.h
index fb386bd55b2..aa21b124956 100644
--- a/mozilla/layout/xul/base/src/nsDeckFrame.h
+++ b/mozilla/layout/xul/base/src/nsDeckFrame.h
@@ -70,8 +70,7 @@ public:
                    PRUint32             aFlags = 0);
 
  
-  NS_IMETHOD GetFrameForPoint(nsPresContext*   aPresContext,
-                              const nsPoint&    aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint&    aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**        aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsLeafBoxFrame.cpp b/mozilla/layout/xul/base/src/nsLeafBoxFrame.cpp
index eba1de178d1..f301ecf0be9 100644
--- a/mozilla/layout/xul/base/src/nsLeafBoxFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsLeafBoxFrame.cpp
@@ -185,8 +185,7 @@ nsLeafBoxFrame::GetMouseThrough(PRBool& aMouseThrough)
 }
 
 NS_IMETHODIMP  
-nsLeafBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                             const nsPoint& aPoint, 
+nsLeafBoxFrame::GetFrameForPoint(const nsPoint& aPoint, 
                              nsFramePaintLayer aWhichLayer,    
                              nsIFrame**     aFrame)
 {   
diff --git a/mozilla/layout/xul/base/src/nsLeafBoxFrame.h b/mozilla/layout/xul/base/src/nsLeafBoxFrame.h
index 7ee7c04bb69..871bb494d9a 100644
--- a/mozilla/layout/xul/base/src/nsLeafBoxFrame.h
+++ b/mozilla/layout/xul/base/src/nsLeafBoxFrame.h
@@ -82,8 +82,7 @@ public:
                nsStyleContext*  aContext,
                nsIFrame*        asPrevInFlow);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                          const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                           nsFramePaintLayer aWhichLayer,    
                           nsIFrame**     aFrame);
    
diff --git a/mozilla/layout/xul/base/src/nsListItemFrame.cpp b/mozilla/layout/xul/base/src/nsListItemFrame.cpp
index f5af51f7311..3d46e559239 100644
--- a/mozilla/layout/xul/base/src/nsListItemFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsListItemFrame.cpp
@@ -80,15 +80,14 @@ nsListItemFrame::GetPrefSize(nsBoxLayoutState& aState, nsSize& aSize)
 }
 
 NS_IMETHODIMP
-nsListItemFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint, 
+nsListItemFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame**     aFrame)
 {
   nsAutoString value;
   mContent->GetAttr(kNameSpaceID_None, nsXULAtoms::allowevents, value);
   if (value.EqualsLiteral("true")) {
-    return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+    return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
   }
   else if (mRect.Contains(aPoint)) {
     if (GetStyleVisibility()->IsVisible()) {
diff --git a/mozilla/layout/xul/base/src/nsListItemFrame.h b/mozilla/layout/xul/base/src/nsListItemFrame.h
index 76a6180d7bd..49b8de3c043 100644
--- a/mozilla/layout/xul/base/src/nsListItemFrame.h
+++ b/mozilla/layout/xul/base/src/nsListItemFrame.h
@@ -57,8 +57,7 @@ public:
 
   // overridden so that children of listitems don't handle mouse events,
   // unless allowevents="true" is specified on the listitem
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsMenuFrame.cpp b/mozilla/layout/xul/base/src/nsMenuFrame.cpp
index 30811cf85e6..418546eefd6 100644
--- a/mozilla/layout/xul/base/src/nsMenuFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsMenuFrame.cpp
@@ -341,12 +341,11 @@ nsMenuFrame::Destroy(nsPresContext* aPresContext)
 
 // Called to prevent events from going to anything inside the menu.
 NS_IMETHODIMP
-nsMenuFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+nsMenuFrame::GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame)
 {
-  nsresult result = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  nsresult result = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
   if (NS_FAILED(result) || *aFrame == this) {
     return result;
   }
diff --git a/mozilla/layout/xul/base/src/nsMenuFrame.h b/mozilla/layout/xul/base/src/nsMenuFrame.h
index ab0ad8fadc1..2e32a22f655 100644
--- a/mozilla/layout/xul/base/src/nsMenuFrame.h
+++ b/mozilla/layout/xul/base/src/nsMenuFrame.h
@@ -108,8 +108,7 @@ public:
   NS_IMETHOD Destroy(nsPresContext* aPresContext);
 
   // Overridden to prevent events from ever going to children of the menu.
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsMenuPopupFrame.cpp b/mozilla/layout/xul/base/src/nsMenuPopupFrame.cpp
index cdec23688e0..adc666e1efe 100644
--- a/mozilla/layout/xul/base/src/nsMenuPopupFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsMenuPopupFrame.cpp
@@ -1167,7 +1167,7 @@ nsMenuPopupFrame::SyncViewWithFrame(nsPresContext* aPresContext,
   // Now that we've positioned the view, sync up the frame's origin.
   nsPoint frameOrigin = GetPosition();
   nsPoint offsetToView;
-  GetOriginToViewOffset(aPresContext, offsetToView, nsnull);
+  GetOriginToViewOffset(offsetToView, nsnull);
   frameOrigin -= offsetToView;
   nsBoxFrame::SetPosition(frameOrigin);
 
@@ -2049,12 +2049,11 @@ nsMenuPopupFrame::Destroy(nsPresContext* aPresContext)
 }
 
 NS_IMETHODIMP
-nsMenuPopupFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint,
+nsMenuPopupFrame::GetFrameForPoint(const nsPoint& aPoint,
                                    nsFramePaintLayer aWhichLayer,    
                                    nsIFrame** aFrame)
 {
-  return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 
diff --git a/mozilla/layout/xul/base/src/nsMenuPopupFrame.h b/mozilla/layout/xul/base/src/nsMenuPopupFrame.h
index 6488690a9e9..403fba5ee7c 100644
--- a/mozilla/layout/xul/base/src/nsMenuPopupFrame.h
+++ b/mozilla/layout/xul/base/src/nsMenuPopupFrame.h
@@ -133,8 +133,7 @@ public:
 
   NS_IMETHOD Destroy(nsPresContext* aPresContext);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsRootBoxFrame.cpp b/mozilla/layout/xul/base/src/nsRootBoxFrame.cpp
index 1186c3a3a8b..921e407d5b3 100644
--- a/mozilla/layout/xul/base/src/nsRootBoxFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsRootBoxFrame.cpp
@@ -102,8 +102,7 @@ public:
   NS_IMETHOD HandleEvent(nsPresContext* aPresContext, 
                          nsGUIEvent*     aEvent,
                          nsEventStatus*  aEventStatus);
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
@@ -259,13 +258,12 @@ nsRootBoxFrame::HandleEvent(nsPresContext* aPresContext,
 }
 
 NS_IMETHODIMP
-nsRootBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                   const nsPoint& aPoint, 
+nsRootBoxFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                    nsFramePaintLayer aWhichLayer,
                                    nsIFrame**     aFrame)
 {
   // this should act like a block, so we need to override
-  return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 nsIAtom*
diff --git a/mozilla/layout/xul/base/src/nsSliderFrame.cpp b/mozilla/layout/xul/base/src/nsSliderFrame.cpp
index 0a51f162407..d378ac19187 100644
--- a/mozilla/layout/xul/base/src/nsSliderFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsSliderFrame.cpp
@@ -714,8 +714,7 @@ nsSliderFrame::SetCurrentPosition(nsIContent* scrollbar, nsIFrame* aThumbFrame,
 
 }
 
-NS_IMETHODIMP  nsSliderFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                             const nsPoint& aPoint,
+NS_IMETHODIMP  nsSliderFrame::GetFrameForPoint(const nsPoint& aPoint,
                                              nsFramePaintLayer aWhichLayer,
                                              nsIFrame**     aFrame)
 {
@@ -728,7 +727,7 @@ NS_IMETHODIMP  nsSliderFrame::GetFrameForPoint(nsPresContext* aPresContext,
     return NS_OK;
   }
 
-  if (NS_SUCCEEDED(nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame)))
+  if (NS_SUCCEEDED(nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame)))
     return NS_OK;
 
   // always return us (if visible)
diff --git a/mozilla/layout/xul/base/src/nsSliderFrame.h b/mozilla/layout/xul/base/src/nsSliderFrame.h
index 0d47c15846e..94e5dc60937 100644
--- a/mozilla/layout/xul/base/src/nsSliderFrame.h
+++ b/mozilla/layout/xul/base/src/nsSliderFrame.h
@@ -185,8 +185,7 @@ public:
                          nsGUIEvent* aEvent,
                          nsEventStatus* aEventStatus);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsSplitterFrame.cpp b/mozilla/layout/xul/base/src/nsSplitterFrame.cpp
index bbdef6d4133..0d34f39e7d2 100644
--- a/mozilla/layout/xul/base/src/nsSplitterFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsSplitterFrame.cpp
@@ -444,8 +444,7 @@ nsSplitterFrame::HandleRelease(nsPresContext* aPresContext,
   return NS_OK;
 }
 
-NS_IMETHODIMP  nsSplitterFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                             const nsPoint& aPoint, 
+NS_IMETHODIMP  nsSplitterFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                              nsFramePaintLayer aWhichLayer,    
                                              nsIFrame**     aFrame)
 {   
@@ -457,7 +456,7 @@ NS_IMETHODIMP  nsSplitterFrame::GetFrameForPoint(nsPresContext* aPresContext,
     return NS_OK;
   }
 
-  nsresult rv = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  nsresult rv = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 
   if (NS_FAILED(rv) &&
       aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND &&
diff --git a/mozilla/layout/xul/base/src/nsSplitterFrame.h b/mozilla/layout/xul/base/src/nsSplitterFrame.h
index 98b0b7c76cd..b83433a698d 100644
--- a/mozilla/layout/xul/base/src/nsSplitterFrame.h
+++ b/mozilla/layout/xul/base/src/nsSplitterFrame.h
@@ -103,8 +103,7 @@ public:
                          nsGUIEvent* aEvent,
                          nsEventStatus* aEventStatus);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/nsStackFrame.cpp b/mozilla/layout/xul/base/src/nsStackFrame.cpp
index e2b15d15e88..825e0acfd96 100644
--- a/mozilla/layout/xul/base/src/nsStackFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsStackFrame.cpp
@@ -89,21 +89,18 @@ nsStackFrame::nsStackFrame(nsIPresShell* aPresShell, nsIBoxLayout* aLayoutManage
 
 
 NS_IMETHODIMP  
-nsStackFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                               const nsPoint& aPoint, 
+nsStackFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                nsFramePaintLayer aWhichLayer,    
                                nsIFrame** aFrame)
 {
   if (aWhichLayer != NS_FRAME_PAINT_LAYER_BACKGROUND)
     return NS_ERROR_FAILURE;
 
-  return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer,
-                                      aFrame);
+  return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 /* virtual */ nsresult
-nsStackFrame::GetFrameForPointChild(nsPresContext*   aPresContext,
-                                    const nsPoint&    aPoint,
+nsStackFrame::GetFrameForPointChild(const nsPoint&    aPoint,
                                     nsFramePaintLayer aWhichLayer,    
                                     nsIFrame*         aChild,
                                     PRBool            aCheckMouseThrough,
@@ -112,12 +109,12 @@ nsStackFrame::GetFrameForPointChild(nsPresContext*   aPresContext,
   if (aWhichLayer != NS_FRAME_PAINT_LAYER_BACKGROUND)
     return NS_ERROR_FAILURE;
 
-  nsresult rv = nsBoxFrame::GetFrameForPointChild(aPresContext, aPoint,
+  nsresult rv = nsBoxFrame::GetFrameForPointChild(aPoint,
                                            NS_FRAME_PAINT_LAYER_FOREGROUND,
                                            aChild, aCheckMouseThrough, aFrame);
   if (NS_SUCCEEDED(rv))
     return rv;
-  return nsBoxFrame::GetFrameForPointChild(aPresContext, aPoint,
+  return nsBoxFrame::GetFrameForPointChild(aPoint,
                                            NS_FRAME_PAINT_LAYER_BACKGROUND,
                                            aChild, aCheckMouseThrough, aFrame);
 }
diff --git a/mozilla/layout/xul/base/src/nsStackFrame.h b/mozilla/layout/xul/base/src/nsStackFrame.h
index e26f3a221fe..6c5c7f6b018 100644
--- a/mozilla/layout/xul/base/src/nsStackFrame.h
+++ b/mozilla/layout/xul/base/src/nsStackFrame.h
@@ -75,15 +75,13 @@ public:
                              nsFramePaintLayer    aWhichLayer,
                              PRUint32             aFlags = 0);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,    
                               nsIFrame**     aFrame);
 
 protected:
 
-  virtual nsresult GetFrameForPointChild(nsPresContext*   aPresContext,
-                                         const nsPoint&    aPoint,
+  virtual nsresult GetFrameForPointChild(const nsPoint&    aPoint,
                                          nsFramePaintLayer aWhichLayer,    
                                          nsIFrame*         aChild,
                                          PRBool            aCheckMouseThrough,
diff --git a/mozilla/layout/xul/base/src/nsTitleBarFrame.cpp b/mozilla/layout/xul/base/src/nsTitleBarFrame.cpp
index 6ab81f1cf54..c73fc4f17cb 100644
--- a/mozilla/layout/xul/base/src/nsTitleBarFrame.cpp
+++ b/mozilla/layout/xul/base/src/nsTitleBarFrame.cpp
@@ -103,13 +103,12 @@ nsTitleBarFrame::GetMouseThrough(PRBool& aMouseThrough)
   return NS_OK;
 }
 
-NS_IMETHODIMP nsTitleBarFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                    const nsPoint& aPoint, 
+NS_IMETHODIMP nsTitleBarFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                     nsFramePaintLayer aWhichLayer,
                                     nsIFrame**     aFrame)
 {
   // override, since we don't want children to get events
-  return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
 }
 
 
diff --git a/mozilla/layout/xul/base/src/nsTitleBarFrame.h b/mozilla/layout/xul/base/src/nsTitleBarFrame.h
index bafa5077b56..21f1694bf8c 100644
--- a/mozilla/layout/xul/base/src/nsTitleBarFrame.h
+++ b/mozilla/layout/xul/base/src/nsTitleBarFrame.h
@@ -54,8 +54,7 @@ public:
                    nsStyleContext*  aContext,
                    nsIFrame*        asPrevInFlow);
 
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint, 
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, 
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);
 
diff --git a/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.cpp b/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.cpp
index e2c71a628f9..d3ce8bd25a0 100644
--- a/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.cpp
+++ b/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.cpp
@@ -125,8 +125,7 @@ nsTreeColFrame::Destroy(nsPresContext* aPresContext)
 }
 
 NS_IMETHODIMP
-nsTreeColFrame::GetFrameForPoint(nsPresContext* aPresContext,
-                                     const nsPoint& aPoint, 
+nsTreeColFrame::GetFrameForPoint(const nsPoint& aPoint, 
                                      nsFramePaintLayer aWhichLayer,
                                      nsIFrame**     aFrame)
 {
@@ -160,7 +159,7 @@ nsTreeColFrame::GetFrameForPoint(nsPresContext* aPresContext,
     }
   }
 
-  nsresult result = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
+  nsresult result = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
   if (result == NS_OK) {
     nsIContent* content = (*aFrame)->GetContent();
     if (content) {
diff --git a/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.h b/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.h
index a10c1b6586e..3ebd6c5c787 100644
--- a/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.h
+++ b/mozilla/layout/xul/base/src/tree/src/nsTreeColFrame.h
@@ -58,8 +58,7 @@ public:
   NS_IMETHOD Destroy(nsPresContext* aPresContext);
 
   // Overridden to capture events.
-  NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
-                              const nsPoint& aPoint,
+  NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
                               nsFramePaintLayer aWhichLayer,
                               nsIFrame**     aFrame);