Bug 825866. Part 8: Mass-rename of nsIView to nsView. r=tnikkel
authorRobert O'Callahan <robert@ocallahan.org>
Fri, 04 Jan 2013 02:23:11 +1300
changeset 127357 504d70c1ca9cd8c150e977feca49970ee9513277
parent 127356 fbcf7d62c9888a71f34e83dcdc0b6597ae0bc2fc
child 127358 042de8e1b27c95f129099cf22d3456af1e547e60
push id297
push userlsblakk@mozilla.com
push dateTue, 26 Mar 2013 17:28:00 +0000
treeherdermozilla-release@64d7b45c34e6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstnikkel
bugs825866
milestone20.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
Bug 825866. Part 8: Mass-rename of nsIView to nsView. r=tnikkel This was autogenerated by basically replacing all occurrences of the word "nsIView" with nsView.
accessible/src/base/nsCoreUtils.cpp
accessible/src/generic/Accessible.cpp
accessible/src/generic/Accessible.h
accessible/src/mac/RootAccessibleWrap.mm
accessible/src/msaa/AccessibleWrap.cpp
content/base/src/Element.cpp
content/base/src/FragmentOrElement.cpp
content/base/src/nsContentUtils.cpp
content/base/src/nsFrameLoader.cpp
content/base/src/nsFrameLoader.h
content/base/src/nsINode.cpp
content/events/src/nsContentEventHandler.cpp
content/events/src/nsEventListenerManager.cpp
content/html/content/src/nsGenericHTMLElement.cpp
content/html/content/src/nsTextEditorState.cpp
content/xul/content/src/nsXULElement.cpp
content/xul/document/src/nsXULDocument.cpp
docshell/base/nsDocShell.cpp
docshell/base/nsIContentViewer.idl
dom/base/nsDOMWindowUtils.cpp
dom/base/nsGlobalWindow.cpp
dom/ipc/TabChild.cpp
dom/plugins/base/nsPluginInstanceOwner.cpp
embedding/browser/webBrowser/nsDocShellTreeOwner.cpp
extensions/widgetutils/src/nsWidgetUtils.cpp
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsDisplayList.cpp
layout/base/nsDocumentViewer.cpp
layout/base/nsIPresShell.h
layout/base/nsLayoutUtils.cpp
layout/base/nsLayoutUtils.h
layout/base/nsPresContext.cpp
layout/base/nsPresShell.cpp
layout/base/nsPresShell.h
layout/forms/nsComboboxControlFrame.cpp
layout/forms/nsComboboxControlFrame.h
layout/forms/nsTextControlFrame.cpp
layout/generic/nsAbsoluteContainingBlock.cpp
layout/generic/nsBlockFrame.cpp
layout/generic/nsContainerFrame.cpp
layout/generic/nsContainerFrame.h
layout/generic/nsFrame.cpp
layout/generic/nsFrame.h
layout/generic/nsFrameSetFrame.cpp
layout/generic/nsGfxScrollFrame.cpp
layout/generic/nsIFrame.h
layout/generic/nsObjectFrame.cpp
layout/generic/nsObjectFrame.h
layout/generic/nsSelection.cpp
layout/generic/nsSubDocumentFrame.cpp
layout/generic/nsSubDocumentFrame.h
layout/printing/nsPrintEngine.cpp
layout/printing/nsPrintEngine.h
layout/tools/layout-debug/src/nsLayoutDebuggingTools.cpp
layout/tools/layout-debug/src/nsRegressionTester.cpp
layout/xul/base/src/nsBox.cpp
layout/xul/base/src/nsBoxFrame.cpp
layout/xul/base/src/nsBoxObject.cpp
layout/xul/base/src/nsListBoxBodyFrame.cpp
layout/xul/base/src/nsMenuPopupFrame.cpp
layout/xul/base/src/nsMenuPopupFrame.h
layout/xul/base/src/nsPopupBoxObject.cpp
layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
tools/trace-malloc/types.dat
view/public/Makefile.in
view/public/nsIView.h
view/public/nsIViewManager.h
view/public/nsView.h
view/src/nsView.cpp
view/src/nsViewManager.cpp
view/src/nsViewManager.h
widget/cocoa/nsDragService.mm
widget/nsIWidget.h
widget/nsIWidgetListener.h
--- a/accessible/src/base/nsCoreUtils.cpp
+++ b/accessible/src/base/nsCoreUtils.cpp
@@ -24,17 +24,17 @@
 #include "nsIPresShell.h"
 #include "nsPresContext.h"
 #include "nsIScrollableFrame.h"
 #include "nsEventStateManager.h"
 #include "nsISelectionPrivate.h"
 #include "nsISelectionController.h"
 #include "nsPIDOMWindow.h"
 #include "nsGUIEvent.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsLayoutUtils.h"
 #include "nsGkAtoms.h"
 
 #include "nsComponentManagerUtils.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "mozilla/dom/Element.h"
 
 #include "nsITreeBoxObject.h"
--- a/accessible/src/generic/Accessible.cpp
+++ b/accessible/src/generic/Accessible.cpp
@@ -44,17 +44,17 @@
 #include "nsIFormControl.h"
 
 #include "nsDeckFrame.h"
 #include "nsLayoutUtils.h"
 #include "nsIPresShell.h"
 #include "nsIStringBundle.h"
 #include "nsPresContext.h"
 #include "nsIFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsIScrollableFrame.h"
 #include "nsFocusManager.h"
 
 #include "nsXPIDLString.h"
 #include "nsUnicharUtils.h"
 #include "nsReadableUtils.h"
 #include "prdtoa.h"
@@ -619,17 +619,17 @@ Accessible::VisibilityState()
   // Walk the parent frame chain to see if there's invisible parent or the frame
   // is in background tab.
   if (!frame->GetStyleVisibility()->IsVisible())
     return states::INVISIBLE;
 
   nsIFrame* curFrame = frame;
   nsPoint framePos(0, 0);
   do {
-    nsIView* view = curFrame->GetView();
+    nsView* view = curFrame->GetView();
     if (view && view->GetVisibility() == nsViewVisibility_kHide)
       return states::INVISIBLE;
 
     // Offscreen state for background tab content and invisible for not selected
     // deck panel.
     nsIFrame* parentFrame = curFrame->GetParent();
     nsDeckFrame* deckFrame = do_QueryFrame(parentFrame);
     if (deckFrame && deckFrame->GetSelectedBox() != curFrame) {
@@ -2010,17 +2010,17 @@ Accessible::RelationByType(uint32_t aTyp
       // If accessible is in its own Window, or is the root of a document,
       // then we should provide NODE_CHILD_OF relation so that MSAA clients
       // can easily get to true parent instead of getting to oleacc's
       // ROLE_WINDOW accessible which will prevent us from going up further
       // (because it is system generated and has no idea about the hierarchy
       // above it).
       nsIFrame *frame = GetFrame();
       if (frame) {
-        nsIView *view = frame->GetViewExternal();
+        nsView *view = frame->GetViewExternal();
         if (view) {
           nsIScrollableFrame *scrollFrame = do_QueryFrame(frame);
           if (scrollFrame || view->GetWidget() || !frame->GetParent())
             rel.AppendTarget(Parent());
         }
       }
 
       return rel;
--- a/accessible/src/generic/Accessible.h
+++ b/accessible/src/generic/Accessible.h
@@ -23,17 +23,17 @@
 #include "nsRefPtrHashtable.h"
 
 struct nsRoleMapEntry;
 
 struct nsRect;
 class nsIContent;
 class nsIFrame;
 class nsIAtom;
-class nsIView;
+class nsView;
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class AccEvent;
 class AccGroupInfo;
 class EmbeddedObjCollector;
--- a/accessible/src/mac/RootAccessibleWrap.mm
+++ b/accessible/src/mac/RootAccessibleWrap.mm
@@ -35,17 +35,17 @@ RootAccessibleWrap::GetNativeType()
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 void
 RootAccessibleWrap::GetNativeWidget(void** aOutView)
 {
   nsIFrame *frame = GetFrame();
   if (frame) {
-    nsIView *view = frame->GetViewExternal();
+    nsView *view = frame->GetViewExternal();
     if (view) {
       nsIWidget *widget = view->GetWidget();
       if (widget) {
         *aOutView = (void**)widget->GetNativeData (NS_NATIVE_WIDGET);
         NS_ASSERTION (*aOutView, 
                       "Couldn't get the native NSView parent we need to connect the accessibility hierarchy!");
       }
     }
--- a/accessible/src/msaa/AccessibleWrap.cpp
+++ b/accessible/src/msaa/AccessibleWrap.cpp
@@ -28,17 +28,17 @@
 
 #include "nsIMutableArray.h"
 #include "nsIFrame.h"
 #include "nsIScrollableFrame.h"
 #include "nsINameSpaceManager.h"
 #include "nsINodeInfo.h"
 #include "nsIServiceManager.h"
 #include "nsTextFormatter.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsEventMap.h"
 #include "nsArrayUtils.h"
 #include "mozilla/Preferences.h"
 
 #include "Accessible2_i.c"
 #include "AccessibleRole.h"
 #include "AccessibleStates.h"
--- a/content/base/src/Element.cpp
+++ b/content/base/src/Element.cpp
@@ -88,17 +88,17 @@
 #include "nsIDOMUserDataHandler.h"
 #include "nsGenericHTMLElement.h"
 #include "nsIEditor.h"
 #include "nsIEditorIMESupport.h"
 #include "nsIEditorDocShell.h"
 #include "nsEventDispatcher.h"
 #include "nsContentCreatorFunctions.h"
 #include "nsIControllers.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIScrollableFrame.h"
 #include "nsXBLInsertionPoint.h"
 #include "mozilla/css/StyleRule.h" /* For nsCSSSelectorList */
 #include "nsCSSRuleProcessor.h"
 #include "nsRuleProcessorData.h"
 #include "nsAsyncDOMEvent.h"
 #include "nsTextNode.h"
--- a/content/base/src/FragmentOrElement.cpp
+++ b/content/base/src/FragmentOrElement.cpp
@@ -87,17 +87,17 @@
 #include "nsIDOMUserDataHandler.h"
 #include "nsGenericHTMLElement.h"
 #include "nsIEditor.h"
 #include "nsIEditorIMESupport.h"
 #include "nsIEditorDocShell.h"
 #include "nsEventDispatcher.h"
 #include "nsContentCreatorFunctions.h"
 #include "nsIControllers.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIScrollableFrame.h"
 #include "nsXBLInsertionPoint.h"
 #include "mozilla/css/StyleRule.h" /* For nsCSSSelectorList */
 #include "nsRuleProcessorData.h"
 #include "nsAsyncDOMEvent.h"
 #include "nsTextNode.h"
 #include "mozilla/dom/NodeListBinding.h"
--- a/content/base/src/nsContentUtils.cpp
+++ b/content/base/src/nsContentUtils.cpp
@@ -6407,19 +6407,19 @@ nsContentUtils::FindPresShellForDocument
 
 nsIWidget*
 nsContentUtils::WidgetForDocument(nsIDocument* aDoc)
 {
   nsIPresShell* shell = FindPresShellForDocument(aDoc);
   if (shell) {
     nsIViewManager* VM = shell->GetViewManager();
     if (VM) {
-      nsIView* rootView = VM->GetRootView();
+      nsView* rootView = VM->GetRootView();
       if (rootView) {
-        nsIView* displayRoot = nsIViewManager::GetDisplayRootFor(rootView);
+        nsView* displayRoot = nsIViewManager::GetDisplayRootFor(rootView);
         if (displayRoot) {
           return displayRoot->GetNearestWidget(nullptr);
         }
       }
     }
   }
 
   return nullptr;
--- a/content/base/src/nsFrameLoader.cpp
+++ b/content/base/src/nsFrameLoader.cpp
@@ -54,17 +54,17 @@
 #include "nsIDocShellHistory.h"
 #include "nsIDOMHTMLDocument.h"
 #include "nsIXULWindow.h"
 #include "nsIEditor.h"
 #include "nsIEditorDocShell.h"
 #include "nsIMozBrowserFrame.h"
 
 #include "nsLayoutUtils.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsAsyncDOMEvent.h"
 
 #include "nsIURI.h"
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 
 #include "nsGkAtoms.h"
 #include "nsINameSpaceManager.h"
@@ -810,17 +810,17 @@ nsFrameLoader::Show(int32_t marginWidth,
       if (rootScrollFrame) {
         presShell->FrameNeedsReflow(rootScrollFrame, nsIPresShell::eResize,
                                     NS_FRAME_IS_DIRTY);
       }
       return true;
     }
   }
 
-  nsIView* view = frame->EnsureInnerView();
+  nsView* view = frame->EnsureInnerView();
   if (!view)
     return false;
 
   if (mRemoteFrame) {
     return ShowRemoteFrame(GetSubDocumentSize(frame));
   }
 
   nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(mDocShell);
@@ -2449,24 +2449,24 @@ nsFrameLoader::SetRemoteBrowser(nsITabPa
   MOZ_ASSERT(!mCurrentRemoteFrame);
   mRemoteFrame = true;
   mRemoteBrowser = static_cast<TabParent*>(aTabParent);
 
   ShowRemoteFrame(nsIntSize(0, 0));
 }
 
 void
-nsFrameLoader::SetDetachedSubdocView(nsIView* aDetachedViews,
+nsFrameLoader::SetDetachedSubdocView(nsView* aDetachedViews,
                                      nsIDocument* aContainerDoc)
 {
   mDetachedSubdocViews = aDetachedViews;
   mContainerDocWhileDetached = aContainerDoc;
 }
 
-nsIView*
+nsView*
 nsFrameLoader::GetDetachedSubdocView(nsIDocument** aContainerDoc) const
 {
   NS_IF_ADDREF(*aContainerDoc = mContainerDocWhileDetached);
   return mDetachedSubdocViews;
 }
 
 /* virtual */ void
 nsFrameLoader::AttributeChanged(nsIDocument* aDocument,
--- a/content/base/src/nsFrameLoader.h
+++ b/content/base/src/nsFrameLoader.h
@@ -21,17 +21,17 @@
 #include "nsFrameMessageManager.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/Attributes.h"
 #include "FrameMetrics.h"
 #include "nsStubMutationObserver.h"
 
 class nsIURI;
 class nsSubDocumentFrame;
-class nsIView;
+class nsView;
 class nsIInProcessContentFrameMessageManager;
 class AutoResetInShow;
 class nsITabParent;
 class nsIDocShellTreeItem;
 class nsIDocShellTreeOwner;
 class nsIDocShellTreeNode;
 class mozIApplication;
 
@@ -291,24 +291,24 @@ public:
    * destroying the nsSubDocumentFrame. If the nsSubdocumentFrame is
    * being reframed we'll restore the detached view when it's recreated,
    * otherwise we'll discard the old presentation and set the detached
    * subdoc view to null. aContainerDoc is the document containing the
    * the subdoc frame. This enables us to detect when the containing
    * document has changed during reframe, so we can discard the presentation 
    * in that case.
    */
-  void SetDetachedSubdocView(nsIView* aDetachedView,
+  void SetDetachedSubdocView(nsView* aDetachedView,
                              nsIDocument* aContainerDoc);
 
   /**
    * Retrieves the detached view and the document containing the view,
    * as set by SetDetachedSubdocView().
    */
-  nsIView* GetDetachedSubdocView(nsIDocument** aContainerDoc) const;
+  nsView* GetDetachedSubdocView(nsIDocument** aContainerDoc) const;
 
 private:
 
   void SetOwnerContent(mozilla::dom::Element* aContent);
 
   bool ShouldUseRemoteProcess();
 
   /**
@@ -387,17 +387,17 @@ private:
 
 public:
   // public because a callback needs these.
   nsRefPtr<nsFrameMessageManager> mMessageManager;
   nsCOMPtr<nsIInProcessContentFrameMessageManager> mChildMessageManager;
 private:
   // Stores the root view of the subdocument while the subdocument is being
   // reframed. Used to restore the presentation after reframing.
-  nsIView* mDetachedSubdocViews;
+  nsView* mDetachedSubdocViews;
   // Stores the containing document of the frame corresponding to this
   // frame loader. This is reference is kept valid while the subframe's
   // presentation is detached and stored in mDetachedSubdocViews. This
   // enables us to detect whether the frame has moved documents during
   // a reframe, so that we know not to restore the presentation.
   nsCOMPtr<nsIDocument> mContainerDocWhileDetached;
 
   bool mDepthTooGreat : 1;
--- a/content/base/src/nsINode.cpp
+++ b/content/base/src/nsINode.cpp
@@ -68,17 +68,17 @@
 #include "nsINodeInfo.h"
 #include "nsIPresShell.h"
 #include "nsIScriptError.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIScrollableFrame.h"
 #include "nsIServiceManager.h"
 #include "nsIURL.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIWebNavigation.h"
 #include "nsIWidget.h"
 #include "nsLayoutStatics.h"
 #include "nsLayoutUtils.h"
 #include "nsMutationEvent.h"
 #include "nsNetUtil.h"
 #include "nsNodeInfoManager.h"
--- a/content/events/src/nsContentEventHandler.cpp
+++ b/content/events/src/nsContentEventHandler.cpp
@@ -11,17 +11,17 @@
 #include "nsISelection.h"
 #include "nsIDOMRange.h"
 #include "nsRange.h"
 #include "nsGUIEvent.h"
 #include "nsCaret.h"
 #include "nsCopySupport.h"
 #include "nsFrameSelection.h"
 #include "nsIFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIContentIterator.h"
 #include "nsTextFragment.h"
 #include "nsTextFrame.h"
 #include "nsISelectionController.h"
 #include "nsISelectionPrivate.h"
 #include "nsContentUtils.h"
 #include "nsLayoutUtils.h"
 #include "nsIMEStateManager.h"
@@ -789,17 +789,17 @@ nsContentEventHandler::OnQueryCharacterA
   NS_ENSURE_TRUE(rootFrame, NS_ERROR_FAILURE);
   nsIWidget* rootWidget = rootFrame->GetNearestWidget();
   NS_ENSURE_TRUE(rootWidget, NS_ERROR_FAILURE);
 
   // The root frame's widget might be different, e.g., the event was fired on
   // a popup but the rootFrame is the document root.
   if (rootWidget != aEvent->widget) {
     NS_PRECONDITION(aEvent->widget, "The event must have the widget");
-    nsIView* view = nsIView::GetViewFor(aEvent->widget);
+    nsView* view = nsView::GetViewFor(aEvent->widget);
     NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
     rootFrame = view->GetFrame();
     NS_ENSURE_TRUE(rootFrame, NS_ERROR_FAILURE);
     rootWidget = rootFrame->GetNearestWidget();
     NS_ENSURE_TRUE(rootWidget, NS_ERROR_FAILURE);
   }
 
   nsQueryContentEvent eventOnRoot(true, NS_QUERY_CHARACTER_AT_POINT,
@@ -977,17 +977,17 @@ nsContentEventHandler::GetStartFrameAndO
 }
 
 nsresult
 nsContentEventHandler::ConvertToRootViewRelativeOffset(nsIFrame* aFrame,
                                                        nsRect& aRect)
 {
   NS_ASSERTION(aFrame, "aFrame must not be null");
 
-  nsIView* view = nullptr;
+  nsView* view = nullptr;
   nsPoint posInView;
   aFrame->GetOffsetFromView(posInView, &view);
   if (!view)
     return NS_ERROR_FAILURE;
   aRect += posInView + view->GetOffsetTo(nullptr);
   return NS_OK;
 }
 
--- a/content/events/src/nsEventListenerManager.cpp
+++ b/content/events/src/nsEventListenerManager.cpp
@@ -21,17 +21,17 @@
 #include "nsIJSEventListener.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptRuntime.h"
 #include "nsLayoutUtils.h"
 #include "nsINameSpaceManager.h"
 #include "nsIContent.h"
 #include "mozilla/dom/Element.h"
 #include "nsIFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsCOMPtr.h"
 #include "nsIServiceManager.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsError.h"
 #include "nsIJSContextStack.h"
 #include "nsIDocument.h"
 #include "nsIPresShell.h"
--- a/content/html/content/src/nsGenericHTMLElement.cpp
+++ b/content/html/content/src/nsGenericHTMLElement.cpp
@@ -32,17 +32,17 @@
 #include "nsILink.h"
 #include "nsPIDOMWindow.h"
 #include "nsIStyleRule.h"
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 #include "nsEscape.h"
 #include "nsIFrame.h"
 #include "nsIScrollableFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIWidget.h"
 #include "nsRange.h"
 #include "nsIPresShell.h"
 #include "nsPresContext.h"
 #include "nsIDocShell.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsINameSpaceManager.h"
--- a/content/html/content/src/nsTextEditorState.cpp
+++ b/content/html/content/src/nsTextEditorState.cpp
@@ -3,17 +3,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsTextEditorState.h"
 
 #include "nsCOMPtr.h"
 #include "nsIPresShell.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsCaret.h"
 #include "nsEditorCID.h"
 #include "nsLayoutCID.h"
 #include "nsITextControlFrame.h" 
 #include "nsIPlaintextEditor.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMDocument.h"
 #include "nsContentCreatorFunctions.h"
--- a/content/xul/content/src/nsXULElement.cpp
+++ b/content/xul/content/src/nsXULElement.cpp
@@ -1659,17 +1659,17 @@ nsXULElement::HideWindowChrome(bool aSho
     nsIPresShell *shell = doc->GetShell();
 
     if (shell) {
         nsIFrame* frame = GetPrimaryFrame();
 
         nsPresContext *presContext = shell->GetPresContext();
 
         if (frame && presContext && presContext->IsChrome()) {
-            nsIView* view = frame->GetClosestView();
+            nsView* view = frame->GetClosestView();
 
             if (view) {
                 nsIWidget* w = view->GetWidget();
                 NS_ENSURE_STATE(w);
                 w->HideWindowChrome(aShouldHide);
             }
         }
     }
--- a/content/xul/document/src/nsXULDocument.cpp
+++ b/content/xul/document/src/nsXULDocument.cpp
@@ -24,17 +24,17 @@
 #include "mozilla/Util.h"
 
 // Note the ALPHABETICAL ORDERING
 #include "nsXULDocument.h"
 
 #include "nsError.h"
 #include "nsIBoxObject.h"
 #include "nsIChromeRegistry.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIContentViewer.h"
 #include "nsGUIEvent.h"
 #include "nsIDOMXULElement.h"
 #include "nsIRDFNode.h"
 #include "nsIRDFRemoteDataSource.h"
 #include "nsIRDFService.h"
 #include "nsIStreamListener.h"
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -60,17 +60,17 @@
 #include "nsXPCOMCID.h"
 #include "nsISeekableStream.h"
 #include "nsAutoPtr.h"
 #include "nsIWritablePropertyBag2.h"
 #include "nsIAppShell.h"
 #include "nsWidgetsCID.h"
 #include "nsDOMJSUtils.h"
 #include "nsIInterfaceRequestorUtils.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIScriptChannel.h"
 #include "nsIOfflineCacheUpdate.h"
 #include "nsITimedChannel.h"
 #include "nsIPrivacyTransitionObserver.h"
 #include "nsCPrefetchService.h"
 #include "nsJSON.h"
 #include "IHistory.h"
@@ -5122,17 +5122,17 @@ nsDocShell::GetVisibility(bool * aVisibi
     if (!presShell)
         return NS_OK;
 
     // get the view manager
     nsIViewManager* vm = presShell->GetViewManager();
     NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
 
     // get the root view
-    nsIView *view = vm->GetRootView(); // views are not ref counted
+    nsView *view = vm->GetRootView(); // views are not ref counted
     NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
 
     // if our root view is hidden, we are not visible
     if (view->GetVisibility() == nsViewVisibility_kHide)
         return NS_OK;
 
     // otherwise, we must walk up the document and view trees checking
     // for a hidden view, unless we're an off screen browser, which 
@@ -7388,25 +7388,25 @@ nsDocShell::RestoreFromHistory()
             previousViewer->Destroy();
         }
     }
 
     // Save off the root view's parent and sibling so that we can insert the
     // new content viewer's root view at the same position.  Also save the
     // bounds of the root view's widget.
 
-    nsIView *rootViewSibling = nullptr, *rootViewParent = nullptr;
+    nsView *rootViewSibling = nullptr, *rootViewParent = nullptr;
     nsIntRect newBounds(0, 0, 0, 0);
 
     nsCOMPtr<nsIPresShell> oldPresShell;
     nsDocShell::GetPresShell(getter_AddRefs(oldPresShell));
     if (oldPresShell) {
         nsIViewManager *vm = oldPresShell->GetViewManager();
         if (vm) {
-            nsIView *oldRootView = vm->GetRootView();
+            nsView *oldRootView = vm->GetRootView();
 
             if (oldRootView) {
                 rootViewSibling = oldRootView->GetNextSibling();
                 rootViewParent = oldRootView->GetParent();
 
                 mContentViewer->GetBounds(newBounds);
             }
         }
@@ -7617,17 +7617,17 @@ nsDocShell::RestoreFromHistory()
         rv = childShell->BeginRestore(nullptr, false);
         NS_ENSURE_SUCCESS(rv, rv);
     }
 
     nsCOMPtr<nsIPresShell> shell;
     nsDocShell::GetPresShell(getter_AddRefs(shell));
 
     nsIViewManager *newVM = shell ? shell->GetViewManager() : nullptr;
-    nsIView *newRootView = newVM ? newVM->GetRootView() : nullptr;
+    nsView *newRootView = newVM ? newVM->GetRootView() : nullptr;
 
     // Insert the new root view at the correct location in the view tree.
     if (container) {
         nsSubDocumentFrame* subDocFrame = do_QueryFrame(container->GetPrimaryFrame());
         rootViewParent = subDocFrame ? subDocFrame->EnsureInnerView() : nullptr;
     }
     if (sibling &&
         sibling->GetShell() &&
--- a/docshell/base/nsIContentViewer.idl
+++ b/docshell/base/nsIContentViewer.idl
@@ -10,26 +10,26 @@ interface nsIPrintSettings;
 
 
 %{ C++
 class nsIWidget;
 class nsIDocument;
 struct nsIntRect;
 class nsIPresShell;
 class nsPresContext;
-class nsIView;
+class nsView;
 class nsDOMNavigationTiming;
 %}
 
 [ptr] native nsIWidgetPtr(nsIWidget);
 [ptr] native nsIDocumentPtr(nsIDocument);
 [ref] native nsIntRectRef(nsIntRect);
 [ptr] native nsIPresShellPtr(nsIPresShell);
 [ptr] native nsPresContextPtr(nsPresContext);
-[ptr] native nsIViewPtr(nsIView);
+[ptr] native nsViewPtr(nsView);
 [ptr] native nsDOMNavigationTimingPtr(nsDOMNavigationTiming);
 
 [scriptable, builtinclass, uuid(b9d92b8b-5623-4079-ae11-36bb341f322e)]
 interface nsIContentViewer : nsISupports
 {
 
   [noscript] void init(in nsIWidgetPtr aParentWidget,
                        [const] in nsIntRectRef aBounds);
@@ -166,14 +166,14 @@ interface nsIContentViewer : nsISupports
   [noscript] void setDocumentInternal(in nsIDocumentPtr aDocument,
                                       in boolean aForceReuseInnerWindow);
   /**
    * Find the view to use as the container view for MakeWindow. Returns
    * null if this will be the root of a view manager hierarchy. In that
    * case, if mParentWidget is null then this document should not even
    * be displayed.
    */
-  [noscript,notxpcom,nostdcall] nsIViewPtr findContainerView();
+  [noscript,notxpcom,nostdcall] nsViewPtr findContainerView();
   /**
    * Set collector for navigation timing data (load, unload events).
    */
   [noscript,notxpcom,nostdcall] void setNavigationTiming(in nsDOMNavigationTimingPtr aTiming);
 };
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -660,17 +660,17 @@ nsDOMWindowUtils::SendMouseEventCommon(c
   nsEventStatus status;
   if (aToWindow) {
     nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
     if (!presShell)
       return NS_ERROR_FAILURE;
     nsIViewManager* viewManager = presShell->GetViewManager();
     if (!viewManager)
       return NS_ERROR_FAILURE;
-    nsIView* view = viewManager->GetRootView();
+    nsView* view = viewManager->GetRootView();
     if (!view)
       return NS_ERROR_FAILURE;
 
     status = nsEventStatus_eIgnore;
     return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
   }
   return widget->DispatchEvent(&event, status);
 }
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -112,17 +112,17 @@
 #include "nsILoadContext.h"
 #include "nsIMarkupDocumentViewer.h"
 #include "nsIPresShell.h"
 #include "nsIProgrammingLanguage.h"
 #include "nsIServiceManager.h"
 #include "nsIScriptGlobalObjectOwner.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIScrollableFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsISelectionController.h"
 #include "nsISelection.h"
 #include "nsIPrompt.h"
 #include "nsIPromptService.h"
 #include "nsIPromptFactory.h"
 #include "nsIWritablePropertyBag2.h"
 #include "nsIWebNavigation.h"
@@ -11035,17 +11035,17 @@ nsGlobalChromeWindow::SetCursor(const ns
     // Need root widget.
     nsCOMPtr<nsIPresShell> presShell;
     mDocShell->GetPresShell(getter_AddRefs(presShell));
     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
 
     nsIViewManager* vm = presShell->GetViewManager();
     NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
 
-    nsIView* rootView = vm->GetRootView();
+    nsView* rootView = vm->GetRootView();
     NS_ENSURE_TRUE(rootView, NS_ERROR_FAILURE);
 
     nsIWidget* widget = rootView->GetNearestWidget(nullptr);
     NS_ENSURE_TRUE(widget, NS_ERROR_FAILURE);
 
     // Call esm and set cursor.
     rv = presContext->EventStateManager()->SetCursor(cursor, nullptr,
                                                      false, 0.0f, 0.0f,
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -50,17 +50,17 @@
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsISecureBrowserUI.h"
 #include "nsIServiceManager.h"
 #include "nsISupportsImpl.h"
 #include "nsIURI.h"
 #include "nsIURIFixup.h"
 #include "nsCDefaultURIFixup.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIWebBrowser.h"
 #include "nsIWebBrowserFocus.h"
 #include "nsIWebBrowserSetup.h"
 #include "nsIWebProgress.h"
 #include "nsIXPCSecurityManager.h"
 #include "nsInterfaceHashtable.h"
 #include "nsPIDOMWindow.h"
 #include "nsPIWindowRoot.h"
--- a/dom/plugins/base/nsPluginInstanceOwner.cpp
+++ b/dom/plugins/base/nsPluginInstanceOwner.cpp
@@ -722,17 +722,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Get
     // would otherwise cause coordinates to be offset incorrectly. (i.e.
     // if the enclosing window if offset from the document window)
     //
     // fixing both the caret and ability to interact issues for a windowless control in a non document aligned windw
     // does not seem to be possible without a change to the flash plugin
     
     nsIWidget* win = mObjectFrame->GetNearestWidget();
     if (win) {
-      nsIView *view = nsIView::GetViewFor(win);
+      nsView *view = nsView::GetViewFor(win);
       NS_ASSERTION(view, "No view for widget");
       nsPoint offset = view->GetOffsetTo(nullptr);
       
       if (offset.x || offset.y) {
         // in the case the two windows are offset from eachother, we do go ahead and return the correct enclosing window
         // so that mouse co-ordinates are not messed up.
         *pvalue = (void*)win->GetNativeData(NS_NATIVE_WINDOW);
         if (*pvalue)
--- a/embedding/browser/webBrowser/nsDocShellTreeOwner.cpp
+++ b/embedding/browser/webBrowser/nsDocShellTreeOwner.cpp
@@ -57,17 +57,17 @@
 #include "nsIPrompt.h"
 #include "nsRect.h"
 #include "nsIWebBrowserChromeFocus.h"
 #include "nsIContent.h"
 #include "imgIContainer.h"
 #include "nsContextMenuInfo.h"
 #include "nsPresContext.h"
 #include "nsIViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsEventListenerManager.h"
 #include "nsIDOMDragEvent.h"
 #include "nsIConstraintValidation.h"
 #include "mozilla/Attributes.h"
 
 using namespace mozilla;
 
 //
@@ -1440,17 +1440,17 @@ ChromeTooltipListener::sTooltipCallback(
     if (docShell) {
       docShell->GetPresShell(getter_AddRefs(shell));
     }
 
     nsIWidget* widget = nullptr;
     if (shell) {
       nsIViewManager* vm = shell->GetViewManager();
       if (vm) {
-        nsIView* view = vm->GetRootView();
+        nsView* view = vm->GetRootView();
         if (view) {
           nsPoint offset;
           widget = view->GetNearestWidget(&offset);
         }
       }
     }
 
     if (!widget) {
--- a/extensions/widgetutils/src/nsWidgetUtils.cpp
+++ b/extensions/widgetutils/src/nsWidgetUtils.cpp
@@ -29,17 +29,17 @@
 #include "nsIObserverService.h"
 #include "nsIDOMEventTarget.h"
 #include "nsPIDOMWindow.h"
 #include "nsIDOMWindow.h"
 #include "nsIDOMCompositionListener.h"
 #include "nsIDOMTextListener.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsIDOMWheelEvent.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsGUIEvent.h"
 #include "nsIViewManager.h"
 #include "nsIContentPolicy.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsIContent.h"
 #include "nsITimer.h"
 
 using namespace mozilla;
@@ -225,17 +225,17 @@ nsWidgetUtils::MouseMove(nsIDOMEvent* aD
   ((nsIDOMMouseEvent*)mouseEvent)->GetScreenX(&x);
   ((nsIDOMMouseEvent*)mouseEvent)->GetScreenY(&y);
 
   int dx = g_lastX - x;
   int dy = g_lastY - y;
   if(g_lastX == MIN_INT || g_lastY == MIN_INT)
     return NS_OK;
 
-  nsIView* aView = mViewManager->GetRootView();
+  nsView* aView = mViewManager->GetRootView();
   if (!aView)
     if (NS_FAILED(UpdateFromEvent(aDOMEvent)))
       return NS_OK;
 
   nsEventStatus status;
   widget::WheelEvent wheelEvent(true, NS_WHEEL_WHEEL, mWidget);
   wheelEvent.deltaMode = nsIDOMWheelEvent::DOM_DELTA_LINE;
   wheelEvent.deltaX = wheelEvent.lineOrPageDeltaX = dx;
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -2541,17 +2541,17 @@ nsCSSFrameConstructor::ConstructRootFram
   viewportFrame = NS_NewViewportFrame(mPresShell, viewportPseudoStyle);
 
   // XXXbz do we _have_ to pass a null content pointer to that frame?
   // Would it really kill us to pass in the root element or something?
   // What would that break?
   viewportFrame->Init(nullptr, nullptr, nullptr);
 
   // Bind the viewport frame to the root view
-  nsIView* rootView = mPresShell->GetViewManager()->GetRootView();
+  nsView* rootView = mPresShell->GetViewManager()->GetRootView();
   viewportFrame->SetView(rootView);
 
   nsContainerFrame::SyncFrameViewProperties(mPresShell->GetPresContext(), viewportFrame,
                                             viewportPseudoStyle, rootView);
   nsContainerFrame::SyncWindowProperties(mPresShell->GetPresContext(), viewportFrame,
                                          rootView);
 
   // The viewport is the containing block for 'fixed' elements
@@ -7637,17 +7637,17 @@ DoApplyRenderingChangeToTree(nsIFrame* a
 static void
 UpdateViewsForTree(nsIFrame* aFrame,
                    nsFrameManager* aFrameManager,
                    nsChangeHint aChange)
 {
   NS_PRECONDITION(gInApplyRenderingChangeToTree,
                   "should only be called within ApplyRenderingChangeToTree");
 
-  nsIView* view = aFrame->GetView();
+  nsView* view = aFrame->GetView();
   if (view) {
     if (aChange & nsChangeHint_SyncFrameView) {
       nsContainerFrame::SyncFrameViewProperties(aFrame->PresContext(),
                                                 aFrame, nullptr, view);
     }
   }
 
   nsIFrame::ChildListIterator lists(aFrame);
--- a/layout/base/nsDisplayList.cpp
+++ b/layout/base/nsDisplayList.cpp
@@ -1037,17 +1037,17 @@ void nsDisplayList::PaintForFrame(nsDisp
                                   uint32_t aFlags) const {
   NS_ASSERTION(mDidComputeVisibility,
                "Must call ComputeVisibility before calling Paint");
 
   nsRefPtr<LayerManager> layerManager;
   bool widgetTransaction = false;
   bool allowRetaining = false;
   bool doBeginTransaction = true;
-  nsIView *view = nullptr;
+  nsView *view = nullptr;
   if (aFlags & PAINT_USE_WIDGET_LAYERS) {
     nsIFrame* rootReferenceFrame = aBuilder->RootReferenceFrame();
     view = rootReferenceFrame->GetView();
     NS_ASSERTION(rootReferenceFrame == nsLayoutUtils::GetDisplayRootFrame(rootReferenceFrame),
                  "Reference frame must be a display root for us to use the layer manager");
     nsIWidget* window = rootReferenceFrame->GetNearestWidget();
     if (window) {
       layerManager = window->GetLayerManager(&allowRetaining);
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -38,17 +38,17 @@
 #include "nsLayoutCID.h"
 #include "nsContentUtils.h"
 #include "nsLayoutStylesheetCache.h"
 #include "mozilla/Preferences.h"
 
 #include "nsViewsCID.h"
 #include "nsIDeviceContextSpec.h"
 #include "nsIViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 
 #include "nsIPageSequenceFrame.h"
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 #include "nsIContentViewerEdit.h"
 #include "nsIContentViewerFile.h"
 #include "mozilla/css/Loader.h"
 #include "nsIMarkupDocumentViewer.h"
@@ -318,22 +318,22 @@ protected:
 private:
   /**
    * Creates a view manager, root view, and widget for the root view, setting
    * mViewManager and mWindow.
    * @param aSize the initial size in appunits
    * @param aContainerView the container view to hook our root view up
    * to as a child, or null if this will be the root view manager
    */
-  nsresult MakeWindow(const nsSize& aSize, nsIView* aContainerView);
+  nsresult MakeWindow(const nsSize& aSize, nsView* aContainerView);
 
   /**
    * Create our device context
    */
-  nsresult CreateDeviceContext(nsIView* aContainerView);
+  nsresult CreateDeviceContext(nsView* aContainerView);
 
   /**
    * If aDoCreation is true, this creates the device context, creates a
    * prescontext if necessary, and calls MakeWindow.
    *
    * If aForceSetNewDocument is false, then SetNewDocument won't be
    * called if the window's current document is already mDocument.
    */
@@ -801,17 +801,17 @@ nsDocumentViewer::InitPresentationStuff(
   }
 
   return NS_OK;
 }
 
 static nsPresContext*
 CreatePresContext(nsIDocument* aDocument,
                   nsPresContext::nsPresContextType aType,
-                  nsIView* aContainerView)
+                  nsView* aContainerView)
 {
   if (aContainerView)
     return new nsPresContext(aDocument, aType);
   return new nsRootPresContext(aDocument, aType);
 }
 
 //-----------------------------------------------
 // This method can be used to initial the "presentation"
@@ -837,17 +837,17 @@ nsDocumentViewer::InitInternal(nsIWidget
   nsAutoScriptBlocker blockScripts;
 
   mParentWidget = aParentWidget; // not ref counted
   mBounds = aBounds;
 
   nsresult rv = NS_OK;
   NS_ENSURE_TRUE(mDocument, NS_ERROR_NULL_POINTER);
 
-  nsIView* containerView = FindContainerView();
+  nsView* containerView = FindContainerView();
 
   bool makeCX = false;
   if (aDoCreation) {
     nsresult rv = CreateDeviceContext(containerView);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // XXXbz this is a nasty hack to do with the fact that we create
     // presentations both in Init() and in Show()...  Ideally we would only do
@@ -1396,17 +1396,17 @@ nsDocumentViewer::Open(nsISupports *aSta
   // doesn't have a widget. The attach call here will properly attach us.
   if (nsIWidget::UsePuppetWidgets() && mPresContext &&
       ShouldAttachToTopLevel()) {
     // If the old view is already attached to our parent, detach
     DetachFromTopLevelWidget();
 
     nsIViewManager *vm = GetViewManager();
     NS_ABORT_IF_FALSE(vm, "no view manager");
-    nsIView* v = vm->GetRootView();
+    nsView* v = vm->GetRootView();
     NS_ABORT_IF_FALSE(v, "no root view");
     NS_ABORT_IF_FALSE(mParentWidget, "no mParentWidget to set");
     v->AttachToTopLevelWidget(mParentWidget);
 
     mAttachedToParent = true;
   }
 
   return NS_OK;
@@ -1543,26 +1543,26 @@ nsDocumentViewer::Destroy()
     mIsSticky = true;
 
     bool savePresentation = mDocument ? mDocument->IsBFCachingAllowed() : true;
 
     // Remove our root view from the view hierarchy.
     if (mPresShell) {
       nsIViewManager *vm = mPresShell->GetViewManager();
       if (vm) {
-        nsIView *rootView = vm->GetRootView();
+        nsView *rootView = vm->GetRootView();
 
         if (rootView) {
           // The invalidate that removing this view causes is dropped because
           // the Freeze call above sets painting to be suppressed for our
           // document. So we do it ourselves and make it happen.
           vm->InvalidateViewNoSuppression(rootView,
             rootView->GetBounds() - rootView->GetPosition());
 
-          nsIView *rootViewParent = rootView->GetParent();
+          nsView *rootViewParent = rootView->GetParent();
           if (rootViewParent) {
             nsIViewManager *parentVM = rootViewParent->GetViewManager();
             if (parentVM) {
               parentVM->RemoveChild(rootView);
             }
           }
         }
       }
@@ -1977,17 +1977,17 @@ nsDocumentViewer::Show(void)
     nsCOMPtr<nsIBaseWindow> base_win(do_QueryReferent(mContainer));
     if (base_win) {
       base_win->GetParentWidget(&mParentWidget);
       if (mParentWidget) {
         mParentWidget->Release(); // GetParentWidget AddRefs, but mParentWidget is weak
       }
     }
 
-    nsIView* containerView = FindContainerView();
+    nsView* containerView = FindContainerView();
 
     nsresult rv = CreateDeviceContext(containerView);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // Create presentation context
     NS_ASSERTION(!mPresContext, "Shouldn't have a prescontext if we have no shell!");
     mPresContext = CreatePresContext(mDocument,
         nsPresContext::eContext_Galley, containerView);
@@ -2255,17 +2255,17 @@ nsDocumentViewer::ClearHistoryEntry()
 {
   mSHEntry = nullptr;
   return NS_OK;
 }
 
 //-------------------------------------------------------
 
 nsresult
-nsDocumentViewer::MakeWindow(const nsSize& aSize, nsIView* aContainerView)
+nsDocumentViewer::MakeWindow(const nsSize& aSize, nsView* aContainerView)
 {
   if (GetIsPrintPreview())
     return NS_OK;
 
   bool shouldAttach = ShouldAttachToTopLevel();
 
   if (shouldAttach) {
     // If the old view is already attached to our parent, detach
@@ -2281,17 +2281,17 @@ nsDocumentViewer::MakeWindow(const nsSiz
 
   rv = mViewManager->Init(dx);
   if (NS_FAILED(rv))
     return rv;
 
   // The root view is always at 0,0.
   nsRect tbounds(nsPoint(0, 0), aSize);
   // Create a view
-  nsIView* view = mViewManager->CreateView(tbounds, aContainerView);
+  nsView* view = mViewManager->CreateView(tbounds, aContainerView);
   if (!view)
     return NS_ERROR_OUT_OF_MEMORY;
 
   // Create a widget if we were given a parent widget or don't have a
   // container view that we can hook up to without a widget.
   // Don't create widgets for ResourceDocs (external resources & svg images),
   // because when they're displayed, they're painted into *another* document's
   // widget.
@@ -2337,28 +2337,28 @@ nsDocumentViewer::MakeWindow(const nsSiz
 
   return rv;
 }
 
 void
 nsDocumentViewer::DetachFromTopLevelWidget()
 {
   if (mViewManager) {
-    nsIView* oldView = mViewManager->GetRootView();
+    nsView* oldView = mViewManager->GetRootView();
     if (oldView && oldView->IsAttachedToTopLevel()) {
       oldView->DetachFromTopLevelWidget();
     }
   }
   mAttachedToParent = false;
 }
 
-nsIView*
+nsView*
 nsDocumentViewer::FindContainerView()
 {
-  nsIView* containerView = nullptr;
+  nsView* containerView = nullptr;
 
   if (mContainer) {
     nsCOMPtr<nsIDocShellTreeItem> docShellItem = do_QueryReferent(mContainer);
     nsCOMPtr<nsPIDOMWindow> pwin(do_GetInterface(docShellItem));
     if (pwin) {
       nsCOMPtr<nsIContent> containerElement = do_QueryInterface(pwin->GetFrameElementInternal());
       if (!containerElement) {
         return nullptr;
@@ -2385,34 +2385,34 @@ nsDocumentViewer::FindContainerView()
         if (f) {
           nsIFrame* subdocFrame = f->GetContentInsertionFrame();
           // subdocFrame might not be a subdocument frame; the frame
           // constructor can treat a <frame> as an inline in some XBL
           // cases. Treat that as display:none, the document is not
           // displayed.
           if (subdocFrame->GetType() == nsGkAtoms::subDocumentFrame) {
             NS_ASSERTION(subdocFrame->GetView(), "Subdoc frames must have views");
-            nsIView* innerView =
+            nsView* innerView =
               static_cast<nsSubDocumentFrame*>(subdocFrame)->EnsureInnerView();
             containerView = innerView;
           } else {
             NS_WARNING("Subdocument container has non-subdocument frame");
           }
         } else {
           NS_WARNING("Subdocument container has no frame");
         }
       }
     }
   }
 
   return containerView;
 }
 
 nsresult
-nsDocumentViewer::CreateDeviceContext(nsIView* aContainerView)
+nsDocumentViewer::CreateDeviceContext(nsView* aContainerView)
 {
   NS_PRECONDITION(!mPresShell && !mWindow,
                   "This will screw up our existing presentation");
   NS_PRECONDITION(mDocument, "Gotta have a document here");
   
   nsIDocument* doc = mDocument->GetDisplayDocument();
   if (doc) {
     NS_ASSERTION(!aContainerView, "External resource document embedded somewhere?");
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -40,17 +40,17 @@
 #include "nsPresArena.h"
 
 class nsIContent;
 class nsIDocument;
 class nsIFrame;
 class nsPresContext;
 class nsStyleSet;
 class nsIViewManager;
-class nsIView;
+class nsView;
 class nsRenderingContext;
 class nsIPageSequenceFrame;
 class nsAString;
 class nsCaret;
 class nsFrameSelection;
 class nsFrameManager;
 class nsILayoutHistoryState;
 class nsIReflowCallback;
@@ -1090,17 +1090,17 @@ public:
                                                  nsIFrame* aFrame,
                                                  const nsRect& aBounds) = 0;
 
   /**
    * Computes the backstop color for the view: transparent if in a transparent
    * widget, otherwise the PresContext default background color. This color is
    * only visible if the contents of the view as a whole are translucent.
    */
-  virtual nscolor ComputeBackstopColor(nsIView* aDisplayRoot) = 0;
+  virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot) = 0;
 
   void ObserveNativeAnonMutationsForPrint(bool aObserve)
   {
     mObservesMutationsForPrint = aObserve;
   }
   bool ObservesNativeAnonMutationsForPrint()
   {
     return mObservesMutationsForPrint;
@@ -1231,17 +1231,17 @@ public:
     /* Update the layer tree and paint ThebesLayers. If this is not specified,
      * we may still have to do it if the layer tree lost ThebesLayer contents
      * we need for compositing. */
     PAINT_LAYERS = 0x01,
     /* Composite layers to the window. */
     PAINT_COMPOSITE = 0x02,
     PAINT_WILL_SEND_DID_PAINT = 0x80
   };
-  virtual void Paint(nsIView* aViewToPaint, const nsRegion& aDirtyRegion,
+  virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
                      uint32_t aFlags) = 0;
   virtual nsresult HandleEvent(nsIFrame*       aFrame,
                                nsGUIEvent*     aEvent,
                                bool            aDontRetargetEvents,
                                nsEventStatus*  aEventStatus) = 0;
   virtual bool ShouldIgnoreInvalidation() = 0;
   /**
    * Notify that we're going to call Paint with PAINT_LAYERS
@@ -1264,17 +1264,17 @@ public:
    */
   virtual void DidPaintWindow() = 0;
 
   /**
    * Ensures that the refresh driver is running, and schedules a view 
    * manager flush on the next tick.
    */
   virtual void ScheduleViewManagerFlush() = 0;
-  virtual void ClearMouseCaptureOnView(nsIView* aView) = 0;
+  virtual void ClearMouseCaptureOnView(nsView* aView) = 0;
   virtual bool IsVisible() = 0;
   virtual void DispatchSynthMouseMove(nsGUIEvent *aEvent, bool aFlushOnHoverChange) = 0;
 
   virtual void SizeOfIncludingThis(nsMallocSizeOfFun aMallocSizeOf,
                                    nsArenaMemoryStats *aArenaObjectsSize,
                                    size_t *aPresShellSize,
                                    size_t *aStyleSetsSize,
                                    size_t *aTextRunsSize,
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -14,17 +14,17 @@
 #include "nsIDOMHTMLDocument.h"
 #include "nsIDOMHTMLElement.h"
 #include "nsFrameList.h"
 #include "nsGkAtoms.h"
 #include "nsIAtom.h"
 #include "nsCSSPseudoElements.h"
 #include "nsCSSAnonBoxes.h"
 #include "nsCSSColorUtils.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsPlaceholderFrame.h"
 #include "nsIScrollableFrame.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsIDOMEvent.h"
 #include "nsGUIEvent.h"
 #include "nsDisplayList.h"
 #include "nsRegion.h"
 #include "nsFrameManager.h"
@@ -772,17 +772,17 @@ nsLayoutUtils::IsGeneratedContentFor(nsI
 nsIFrame*
 nsLayoutUtils::GetCrossDocParentFrame(const nsIFrame* aFrame,
                                       nsPoint* aExtraOffset)
 {
   nsIFrame* p = aFrame->GetParent();
   if (p)
     return p;
 
-  nsIView* v = aFrame->GetView();
+  nsView* v = aFrame->GetView();
   if (!v)
     return nullptr;
   v = v->GetParent(); // anonymous inner view
   if (!v)
     return nullptr;
   if (aExtraOffset) {
     *aExtraOffset += v->GetPosition();
   }
@@ -1005,26 +1005,26 @@ nsIFrame* nsLayoutUtils::GetLastSibling(
   nsIFrame* next;
   while ((next = aFrame->GetNextSibling()) != nullptr) {
     aFrame = next;
   }
   return aFrame;
 }
 
 // static
-nsIView*
-nsLayoutUtils::FindSiblingViewFor(nsIView* aParentView, nsIFrame* aFrame) {
+nsView*
+nsLayoutUtils::FindSiblingViewFor(nsView* aParentView, nsIFrame* aFrame) {
   nsIFrame* parentViewFrame = aParentView->GetFrame();
   nsIContent* parentViewContent = parentViewFrame ? parentViewFrame->GetContent() : nullptr;
-  for (nsIView* insertBefore = aParentView->GetFirstChild(); insertBefore;
+  for (nsView* insertBefore = aParentView->GetFirstChild(); insertBefore;
        insertBefore = insertBefore->GetNextSibling()) {
     nsIFrame* f = insertBefore->GetFrame();
     if (!f) {
       // this view could be some anonymous view attached to a meaningful parent
-      for (nsIView* searchView = insertBefore->GetParent(); searchView;
+      for (nsView* searchView = insertBefore->GetParent(); searchView;
            searchView = searchView->GetParent()) {
         f = searchView->GetFrame();
         if (f) {
           break;
         }
       }
       NS_ASSERTION(f, "Can't find a frame anywhere!");
     }
@@ -1222,17 +1222,17 @@ nsPoint
 nsLayoutUtils::GetEventCoordinatesRelativeTo(nsIWidget* aWidget,
                                              const nsIntPoint aPoint,
                                              nsIFrame* aFrame)
 {
   if (!aFrame || !aWidget) {
     return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
   }
 
-  nsIView* view = aFrame->GetView();
+  nsView* view = aFrame->GetView();
   if (view) {
     nsIWidget* frameWidget = view->GetWidget();
     if (frameWidget && frameWidget == aWidget) {
       // Special case this cause it happens a lot.
       // This also fixes bug 664707, events in the extra-special case of select
       // dropdown popups that are transformed.
       nsPresContext* presContext = aFrame->PresContext();
       nsPoint pt(presContext->DevPixelsToAppUnits(aPoint.x),
@@ -1250,17 +1250,17 @@ nsLayoutUtils::GetEventCoordinatesRelati
   for (nsIFrame* f = aFrame; f; f = GetCrossDocParentFrame(f)) {
     if (f->IsTransformed()) {
       transformFound = true;
     }
 
     rootFrame = f;
   }
 
-  nsIView* rootView = rootFrame->GetView();
+  nsView* rootView = rootFrame->GetView();
   if (!rootView) {
     return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
   }
 
   nsPoint widgetToView = TranslateWidgetToView(rootFrame->PresContext(),
                                                aWidget, aPoint, rootView);
 
   if (widgetToView == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
@@ -1568,17 +1568,17 @@ static nsIntPoint GetWidgetOffset(nsIWid
   }
   aRootWidget = aWidget;
   return offset;
 }
 
 nsPoint
 nsLayoutUtils::TranslateWidgetToView(nsPresContext* aPresContext,
                                      nsIWidget* aWidget, nsIntPoint aPt,
-                                     nsIView* aView)
+                                     nsView* aView)
 {
   nsPoint viewOffset;
   nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
   if (!viewWidget) {
     return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
   }
 
   nsIWidget* fromRoot;
@@ -1731,17 +1731,17 @@ nsLayoutUtils::GetFramesForArea(nsIFrame
 
 nsresult
 nsLayoutUtils::PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
                           const nsRegion& aDirtyRegion, nscolor aBackstop,
                           uint32_t aFlags)
 {
   SAMPLE_LABEL("nsLayoutUtils","PaintFrame");
   if (aFlags & PAINT_WIDGET_LAYERS) {
-    nsIView* view = aFrame->GetView();
+    nsView* view = aFrame->GetView();
     if (!(view && view->GetWidget() && GetDisplayRootFrame(aFrame) == aFrame)) {
       aFlags &= ~PAINT_WIDGET_LAYERS;
       NS_ASSERTION(aRenderingContext, "need a rendering context");
     }
   }
 
   nsPresContext* presContext = aFrame->PresContext();
   nsIPresShell* presShell = presContext->PresShell();
@@ -1893,17 +1893,17 @@ nsLayoutUtils::PaintFrame(nsRenderingCon
     // can monkey with the contents if necessary.
     canvasArea.IntersectRect(canvasArea, visibleRegion.GetBounds());
     rv = presShell->AddCanvasBackgroundColorItem(
            builder, list, aFrame, canvasArea, aBackstop);
 
     // If the passed in backstop color makes us draw something different from
     // normal, we need to flush layers.
     if ((aFlags & PAINT_WIDGET_LAYERS) && !willFlushRetainedLayers) {
-      nsIView* view = aFrame->GetView();
+      nsView* view = aFrame->GetView();
       if (view) {
         nscolor backstop = presShell->ComputeBackstopColor(view);
         // The PresShell's canvas background color doesn't get updated until
         // EnterPresShell, so this check has to be done after that.
         nscolor canvasColor = presShell->GetCanvasBackground();
         if (NS_ComposeColors(aBackstop, canvasColor) !=
             NS_ComposeColors(backstop, canvasColor)) {
           willFlushRetainedLayers = true;
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -21,17 +21,17 @@ class nsFontFaceList;
 class nsHTMLCanvasElement;
 class nsHTMLVideoElement;
 class nsIImageLoadingContent;
 
 #include "nsChangeHint.h"
 #include "nsStyleContext.h"
 #include "nsAutoPtr.h"
 #include "nsStyleSet.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIFrame.h"
 #include "nsThreadUtils.h"
 #include "nsIPresShell.h"
 #include "nsIPrincipal.h"
 #include "gfxPattern.h"
 #include "imgIContainer.h"
 #include "nsCSSPseudoElements.h"
 #include "nsHTMLReflowState.h"
@@ -267,17 +267,17 @@ public:
 
   /**
    * FindSiblingViewFor locates the child of aParentView that aFrame's
    * view should be inserted 'above' (i.e., before in sibling view
    * order).  This is the first child view of aParentView whose
    * corresponding content is before aFrame's content (view siblings
    * are in reverse content order).
    */
-  static nsIView* FindSiblingViewFor(nsIView* aParentView, nsIFrame* aFrame);
+  static nsView* FindSiblingViewFor(nsView* aParentView, nsIFrame* aFrame);
 
   /**
    * Get the parent of aFrame. If aFrame is the root frame for a document,
    * and the document has a parent document in the same view hierarchy, then
    * we try to return the subdocumentframe in the parent document.
    * @param aExtraOffset [in/out] if non-null, then as we cross documents
    * an extra offset may be required and it will be added to aCrossDocOffset.
    * Be careful dealing with this extra offset as it is in app units of the
@@ -466,17 +466,17 @@ public:
    * @param aPresContext the PresContext for the view
    * @param aWidget the widget
    * @param aPt the point relative to the widget
    * @param aView  view to which returned coordinates are relative
    * @return the point in the view's coordinates
    */
   static nsPoint TranslateWidgetToView(nsPresContext* aPresContext,
                                        nsIWidget* aWidget, nsIntPoint aPt,
-                                       nsIView* aView);
+                                       nsView* aView);
 
   /**
    * Given a matrix and a point, let T be the transformation matrix translating points
    * in the coordinate space with origin aOrigin to the coordinate space used by the
    * matrix.  If M is the stored matrix, this function returns (T-1)MT, the matrix
    * that's equivalent to aMatrix but in the coordinate space that treats aOrigin
    * as the origin.
    *
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -2513,17 +2513,17 @@ nsPresContext::IsRootContentDocument()
   // not chrome, and we either have no parent or our parent is chrome.
   if (mDocument->IsResourceDoc()) {
     return false;
   }
   if (IsChrome()) {
     return false;
   }
   // We may not have a root frame, so use views.
-  nsIView* view = PresShell()->GetViewManager()->GetRootView();
+  nsView* view = PresShell()->GetViewManager()->GetRootView();
   if (!view) {
     return false;
   }
   view = view->GetParent(); // anonymous inner view
   if (!view) {
     return true;
   }
   view = view->GetParent(); // subdocumentframe's view
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -36,17 +36,17 @@
 #include "nsCSSStyleSheet.h" // XXX for UA sheet loading hack, can this go away please?
 #include "nsIDOMCSSStyleSheet.h"  // for Pref-related rule management (bugs 22963,20760,31816)
 #include "nsAnimationManager.h"
 #include "nsINameSpaceManager.h"  // for Pref-related rule management (bugs 22963,20760,31816)
 #include "nsIServiceManager.h"
 #include "nsFrame.h"
 #include "FrameLayerBuilder.h"
 #include "nsViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsCRTGlue.h"
 #include "prlog.h"
 #include "prprf.h"
 #include "prinrval.h"
 #include "nsTArray.h"
 #include "nsCOMArray.h"
 #include "nsHashtable.h"
 #include "nsContainerFrame.h"
@@ -3442,36 +3442,36 @@ PresShell::ScheduleViewManagerFlush()
 }
 
 void
 PresShell::DispatchSynthMouseMove(nsGUIEvent *aEvent,
                                   bool aFlushOnHoverChange)
 {
   uint32_t hoverGenerationBefore = mFrameConstructor->GetHoverGeneration();
   nsEventStatus status;
-  nsIView* targetView = nsIView::GetViewFor(aEvent->widget);
+  nsView* targetView = nsView::GetViewFor(aEvent->widget);
   targetView->GetViewManager()->DispatchEvent(aEvent, targetView, &status);
   if (aFlushOnHoverChange &&
       hoverGenerationBefore != mFrameConstructor->GetHoverGeneration()) {
     // Flush so that the resulting reflow happens now so that our caller
     // can suppress any synthesized mouse moves caused by that reflow.
     FlushPendingNotifications(Flush_Layout);
   }
 }
 
 void
-PresShell::ClearMouseCaptureOnView(nsIView* aView)
+PresShell::ClearMouseCaptureOnView(nsView* aView)
 {
   if (gCaptureInfo.mContent) {
     if (aView) {
       // if a view was specified, ensure that the captured content is within
       // this view.
       nsIFrame* frame = gCaptureInfo.mContent->GetPrimaryFrame();
       if (frame) {
-        nsIView* view = frame->GetClosestView();
+        nsView* view = frame->GetClosestView();
         // if there is no view, capturing won't be handled any more, so
         // just release the capture.
         if (view) {
           do {
             if (view == aView) {
               NS_RELEASE(gCaptureInfo.mContent);
               // the view containing the captured content likely disappeared so
               // disable capture for now.
@@ -4375,17 +4375,17 @@ PresShell::RenderDocument(const nsRect& 
   if (aThebesContext->CurrentMatrix().HasNonIntegerTranslation()) {
     flags |= nsLayoutUtils::PAINT_IN_TRANSFORM;
   }
   if (!(aFlags & RENDER_ASYNC_DECODE_IMAGES)) {
     flags |= nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES;
   }
   if (aFlags & RENDER_USE_WIDGET_LAYERS) {
     // We only support using widget layers on display root's with widgets.
-    nsIView* view = rootFrame->GetView();
+    nsView* view = rootFrame->GetView();
     if (view && view->GetWidget() &&
         nsLayoutUtils::GetDisplayRootFrame(rootFrame) == rootFrame) {
       flags |= nsLayoutUtils::PAINT_WIDGET_LAYERS;
     }
   }
   if (!(aFlags & RENDER_CARET)) {
     wouldFlushRetainedLayers = true;
     flags |= nsLayoutUtils::PAINT_HIDE_CARET;
@@ -4945,17 +4945,17 @@ void PresShell::UpdateCanvasBackground()
   }
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     if (TabChild* tabChild = GetTabChildFrom(this)) {
       tabChild->SetBackgroundColor(mCanvasBackgroundColor);
     }
   }
 }
 
-nscolor PresShell::ComputeBackstopColor(nsIView* aDisplayRoot)
+nscolor PresShell::ComputeBackstopColor(nsView* aDisplayRoot)
 {
   nsIWidget* widget = aDisplayRoot->GetWidget();
   if (widget && (widget->GetTransparencyMode() != eTransparencyOpaque ||
                  widget->WidgetPaintsBackground())) {
     // Within a transparent widget, so the backstop color must be
     // totally transparent.
     return NS_RGBA(0,0,0,0);
   }
@@ -4968,17 +4968,17 @@ nscolor PresShell::ComputeBackstopColor(
 struct PaintParams {
   nscolor mBackgroundColor;
 };
 
 LayerManager* PresShell::GetLayerManager()
 {
   NS_ASSERTION(mViewManager, "Should have view manager");
 
-  nsIView* rootView = mViewManager->GetRootView();
+  nsView* rootView = mViewManager->GetRootView();
   if (rootView) {
     if (nsIWidget* widget = rootView->GetWidget()) {
       return widget->GetLayerManager();
     }
   }
   return nullptr;
 }
 
@@ -5070,32 +5070,32 @@ void PresShell::SynthesizeMouseMove(bool
  * view hierarchy (i.e., added later) are preferred over their siblings.
  * This is adequate for finding the "topmost" floating view under a point,
  * given that floating views don't supporting having a specific z-index.
  * 
  * We cannot exit early when aPt is outside the view bounds, because floating
  * views aren't necessarily included in their parent's bounds, so this could
  * traverse the entire view hierarchy --- use carefully.
  */
-static nsIView* FindFloatingViewContaining(nsIView* aView, nsPoint aPt)
+static nsView* FindFloatingViewContaining(nsView* aView, nsPoint aPt)
 {
   if (aView->GetVisibility() == nsViewVisibility_kHide)
     // No need to look into descendants.
     return nullptr;
 
   nsIFrame* frame = aView->GetFrame();
   if (frame) {
     if (!frame->IsVisibleConsideringAncestors(nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) ||
         !frame->PresContext()->PresShell()->IsActive()) {
       return nullptr;
     }
   }
 
-  for (nsIView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
-    nsIView* r = FindFloatingViewContaining(v, v->ConvertFromParentCoords(aPt));
+  for (nsView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
+    nsView* r = FindFloatingViewContaining(v, v->ConvertFromParentCoords(aPt));
     if (r)
       return r;
   }
 
   if (aView->GetFloating() && aView->HasWidget() &&
       aView->GetDimensions().Contains(aPt))
     return aView;
     
@@ -5106,33 +5106,33 @@ static nsIView* FindFloatingViewContaini
  * This finds the first view containing the given point in a postorder
  * traversal of the view tree that contains the point, assuming that the
  * point is not in a floating view.  It assumes that only floating views
  * extend outside the bounds of their parents.
  *
  * This methods should only be called if FindFloatingViewContaining
  * returns null.
  */
-static nsIView* FindViewContaining(nsIView* aView, nsPoint aPt)
+static nsView* FindViewContaining(nsView* aView, nsPoint aPt)
 {
   if (!aView->GetDimensions().Contains(aPt) ||
       aView->GetVisibility() == nsViewVisibility_kHide) {
     return nullptr;
   }
 
   nsIFrame* frame = aView->GetFrame();
   if (frame) {
     if (!frame->IsVisibleConsideringAncestors(nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) ||
         !frame->PresContext()->PresShell()->IsActive()) {
       return nullptr;
     }
   }
 
-  for (nsIView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
-    nsIView* r = FindViewContaining(v, v->ConvertFromParentCoords(aPt));
+  for (nsView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
+    nsView* r = FindViewContaining(v, v->ConvertFromParentCoords(aPt));
     if (r)
       return r;
   }
 
   return aView;
 }
 
 void
@@ -5146,17 +5146,17 @@ PresShell::ProcessSynthMouseMoveEvent(bo
   }
 
   // allow new event to be posted while handling this one only if the
   // source of the event is a scroll (to prevent infinite reflow loops)
   if (aFromScroll) {
     mSynthMouseMoveEvent.Forget();
   }
 
-  nsIView* rootView = mViewManager ? mViewManager->GetRootView() : nullptr;
+  nsView* rootView = mViewManager ? mViewManager->GetRootView() : nullptr;
   if (mMouseLocation == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) ||
       !rootView || !rootView->HasWidget() || !mPresContext) {
     mSynthMouseMoveEvent.Forget();
     return;
   }
 
   NS_ASSERTION(mPresContext->IsRoot(), "Only a root pres shell should be here");
 
@@ -5170,17 +5170,17 @@ PresShell::ProcessSynthMouseMoveEvent(bo
 #endif
 
   int32_t APD = mPresContext->AppUnitsPerDevPixel();
 
   // We need a widget to put in the event we are going to dispatch so we look
   // for a view that has a widget and the mouse location is over. We first look
   // for floating views, if there isn't one we use the root view. |view| holds
   // that view.
-  nsIView* view = nullptr;
+  nsView* view = nullptr;
 
   // The appunits per devpixel ratio of |view|.
   int32_t viewAPD;
 
   // refPoint will be mMouseLocation relative to the widget of |view|, the
   // widget we will put in the event we dispatch, in viewAPD appunits
   nsPoint refpoint(0, 0);
 
@@ -5188,17 +5188,17 @@ PresShell::ProcessSynthMouseMoveEvent(bo
   // the mouse is over. pointVM is the VM of that pres shell.
   nsIViewManager *pointVM = nullptr;
 
   // This could be a bit slow (traverses entire view hierarchy)
   // but it's OK to do it once per synthetic mouse event
   view = FindFloatingViewContaining(rootView, mMouseLocation);
   if (!view) {
     view = rootView;
-    nsIView *pointView = FindViewContaining(rootView, mMouseLocation);
+    nsView *pointView = FindViewContaining(rootView, mMouseLocation);
     // pointView can be null in situations related to mouse capture
     pointVM = (pointView ? pointView : view)->GetViewManager();
     refpoint = mMouseLocation + rootView->ViewToWidgetOffset();
     viewAPD = APD;
   } else {
     pointVM = view->GetViewManager();
     nsIFrame* frame = view->GetFrame();
     NS_ASSERTION(frame, "floating views can't be anonymous");
@@ -5242,17 +5242,17 @@ public:
   }
 
 private:
   PresShell* mShell;
   uint32_t mFlags;
 };
 
 void
-PresShell::Paint(nsIView*        aViewToPaint,
+PresShell::Paint(nsView*        aViewToPaint,
                  const nsRegion& aDirtyRegion,
                  uint32_t        aFlags)
 {
   SAMPLE_LABEL("Paint", "PresShell::Paint");
   NS_ASSERTION(!mIsDestroying, "painting a destroyed PresShell");
   NS_ASSERTION(aViewToPaint, "null view");
 
   nsAutoNotifyDidPaint notifyDidPaint(this, aFlags);
@@ -5576,17 +5576,17 @@ PresShell::RecordMouseLocation(nsGUIEven
 
   if ((aEvent->message == NS_MOUSE_MOVE &&
        static_cast<nsMouseEvent*>(aEvent)->reason == nsMouseEvent::eReal) ||
       aEvent->message == NS_MOUSE_ENTER ||
       aEvent->message == NS_MOUSE_BUTTON_DOWN ||
       aEvent->message == NS_MOUSE_BUTTON_UP) {
     nsIFrame* rootFrame = GetRootFrame();
     if (!rootFrame) {
-      nsIView* rootView = mViewManager->GetRootView();
+      nsView* rootView = mViewManager->GetRootView();
       mMouseLocation = nsLayoutUtils::TranslateWidgetToView(mPresContext,
         aEvent->widget, aEvent->refPoint, rootView);
     } else {
       mMouseLocation =
         nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, rootFrame);
     }
 #ifdef DEBUG_MOUSE_LOCATION
     if (aEvent->message == NS_MOUSE_ENTER)
@@ -5673,17 +5673,17 @@ FindAnyTarget(const uint32_t& aKey, nsCO
       return PL_DHASH_STOP;
     }
   }
   return PL_DHASH_NEXT;
 }
 
 nsIFrame* GetNearestFrameContainingPresShell(nsIPresShell* aPresShell)
 {
-  nsIView* view = aPresShell->GetViewManager()->GetRootView();
+  nsView* view = aPresShell->GetViewManager()->GetRootView();
   while (view && !view->GetFrame()) {
     view = view->GetParent();
   }
 
   nsIFrame* frame = nullptr;
   if (view) {
     frame = view->GetFrame();
   }
@@ -6796,17 +6796,17 @@ PresShell::AdjustContextMenuKeyEvent(nsM
     rootPC->PresShell()->GetViewManager()->
       GetRootWidget(getter_AddRefs(aEvent->widget));
 
     if (aEvent->widget) {
       // default the refpoint to the topleft of our document
       nsPoint offset(0, 0);
       nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
       if (rootFrame) {
-        nsIView* view = rootFrame->GetClosestView(&offset);
+        nsView* view = rootFrame->GetClosestView(&offset);
         offset += view->GetOffsetToWidget(aEvent->widget);
         aEvent->refPoint =
           offset.ToNearestPixels(mPresContext->AppUnitsPerDevPixel());
       }
     }
   } else {
     aEvent->widget = nullptr;
   }
@@ -6939,17 +6939,17 @@ PresShell::PrepareToUseCaretPosition(nsI
   nsPresContext* presContext = GetPresContext();
 
   // get caret position relative to the closest view
   nsRect caretCoords;
   nsIFrame* caretFrame = caret->GetGeometry(domSelection, &caretCoords);
   if (!caretFrame)
     return false;
   nsPoint viewOffset;
-  nsIView* view = caretFrame->GetClosestView(&viewOffset);
+  nsView* view = caretFrame->GetClosestView(&viewOffset);
   if (!view)
     return false;
   // and then get the caret coords relative to the event widget
   if (aEventWidget) {
     viewOffset += view->GetOffsetToWidget(aEventWidget);
   }
   caretCoords.MoveBy(viewOffset);
 
@@ -7061,17 +7061,17 @@ PresShell::GetCurrentItemAndPositionForE
   nsIFrame *frame = focusedContent->GetPrimaryFrame();
   if (frame) {
     NS_ASSERTION(frame->PresContext() == GetPresContext(),
       "handling event for focused content that is not in our document?");
 
     nsPoint frameOrigin(0, 0);
 
     // Get the frame's origin within its view
-    nsIView *view = frame->GetClosestView(&frameOrigin);
+    nsView *view = frame->GetClosestView(&frameOrigin);
     NS_ASSERTION(view, "No view for frame");
 
     // View's origin relative the widget
     if (aRootWidget) {
       frameOrigin += view->GetOffsetToWidget(aRootWidget);
     }
 
     // Start context menu down and to the right from top left of frame
@@ -7174,17 +7174,17 @@ PresShell::DidPaintWindow()
 }
 
 bool
 PresShell::IsVisible()
 {
   if (!mViewManager)
     return false;
 
-  nsIView* view = mViewManager->GetRootView();
+  nsView* view = mViewManager->GetRootView();
   if (!view)
     return true;
 
   // inner view of subdoc frame
   view = view->GetParent();
   if (!view)
     return true;
   
@@ -7629,17 +7629,17 @@ PresShell::DoReflow(nsIFrame* target, bo
 
 #ifdef DEBUG
 void
 PresShell::DoVerifyReflow()
 {
   if (GetVerifyReflowEnable()) {
     // First synchronously render what we have so far so that we can
     // see it.
-    nsIView* rootView = mViewManager->GetRootView();
+    nsView* rootView = mViewManager->GetRootView();
     mViewManager->InvalidateView(rootView);
 
     FlushPendingNotifications(Flush_Layout);
     mInVerifyReflow = true;
     bool ok = VerifyIncrementalReflow();
     mInVerifyReflow = false;
     if (VERIFY_REFLOW_ALL & gVerifyReflowFlags) {
       printf("ProcessReflowCommands: finished (%s)\n",
@@ -8044,17 +8044,17 @@ CompareTrees(nsPresContext* aFirstPresCo
                        "child counts don't match: ");
       printf("%d != %d\n", l1, l2);
       if (0 == (VERIFY_REFLOW_ALL & gVerifyReflowFlags)) {
         break;
       }
     }
 
     nsIntRect r1, r2;
-    nsIView* v1, *v2;
+    nsView* v1, *v2;
     for (nsFrameList::Enumerator e1(kids1), e2(kids2);
          ;
          e1.Next(), e2.Next()) {
       nsIFrame* k1 = e1.get();
       nsIFrame* k2 = e2.get();
       if (((nullptr == k1) && (nullptr != k2)) ||
           ((nullptr != k1) && (nullptr == k2))) {
         ok = false;
@@ -8289,30 +8289,30 @@ PresShell::VerifyIncrementalReflow()
                                         nsPresContext::eContext_Galley);
   NS_ENSURE_TRUE(cx, false);
 
   nsDeviceContext *dc = mPresContext->DeviceContext();
   nsresult rv = cx->Init(dc);
   NS_ENSURE_SUCCESS(rv, false);
 
   // Get our scrolling preference
-  nsIView* rootView = mViewManager->GetRootView();
+  nsView* rootView = mViewManager->GetRootView();
   NS_ENSURE_TRUE(rootView->HasWidget(), false);
   nsIWidget* parentWidget = rootView->GetWidget();
 
   // Create a new view manager.
   nsCOMPtr<nsIViewManager> vm = do_CreateInstance(kViewManagerCID);
   NS_ENSURE_TRUE(vm, false);
   rv = vm->Init(dc);
   NS_ENSURE_SUCCESS(rv, false);
 
   // Create a child window of the parent that is our "root view/window"
   // Create a view
   nsRect tbounds = mPresContext->GetVisibleArea();
-  nsIView* view = vm->CreateView(tbounds, nullptr);
+  nsView* view = vm->CreateView(tbounds, nullptr);
   NS_ENSURE_TRUE(view, false);
 
   //now create the widget for the view
   rv = view->CreateWidgetForParent(parentWidget, nullptr, true);
   NS_ENSURE_SUCCESS(rv, false);
 
   // Setup hierarchical relationship in view manager
   vm->SetRootView(view);
--- a/layout/base/nsPresShell.h
+++ b/layout/base/nsPresShell.h
@@ -178,17 +178,17 @@ public:
   virtual void SetIgnoreViewportScrolling(bool aIgnore);
 
   virtual void SetDisplayPort(const nsRect& aDisplayPort);
 
   virtual nsresult SetResolution(float aXResolution, float aYResolution);
 
   //nsIViewObserver interface
 
-  virtual void Paint(nsIView* aViewToPaint, const nsRegion& aDirtyRegion,
+  virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
                      uint32_t aFlags);
   virtual nsresult HandleEvent(nsIFrame*       aFrame,
                                nsGUIEvent*     aEvent,
                                bool            aDontRetargetEvents,
                                nsEventStatus*  aEventStatus);
   virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(nsIContent* aTargetContent,
                                                         nsEvent* aEvent,
                                                         nsEventStatus* aStatus);
@@ -196,17 +196,17 @@ public:
                                                         nsIDOMEvent* aEvent,
                                                         nsEventStatus* aStatus);
   virtual bool ShouldIgnoreInvalidation();
   virtual void WillPaint(bool aWillSendDidPaint);
   virtual void WillPaintWindow(bool aWillSendDidPaint);
   virtual void DidPaintWindow();
   virtual void ScheduleViewManagerFlush();
   virtual void DispatchSynthMouseMove(nsGUIEvent *aEvent, bool aFlushOnHoverChange);
-  virtual void ClearMouseCaptureOnView(nsIView* aView);
+  virtual void ClearMouseCaptureOnView(nsView* aView);
   virtual bool IsVisible();
 
   // caret handling
   virtual NS_HIDDEN_(already_AddRefed<nsCaret>) GetCaret() const;
   virtual NS_HIDDEN_(void) MaybeInvalidateCaretPosition();
   NS_IMETHOD SetCaretEnabled(bool aInEnable);
   NS_IMETHOD SetCaretReadOnly(bool aReadOnly);
   NS_IMETHOD GetCaretEnabled(bool *aOutEnabled);
@@ -298,17 +298,17 @@ public:
                                                 nscolor aBackstopColor,
                                                 uint32_t aFlags);
 
   virtual nsresult AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
                                                  nsDisplayList& aList,
                                                  nsIFrame* aFrame,
                                                  const nsRect& aBounds);
 
-  virtual nscolor ComputeBackstopColor(nsIView* aDisplayRoot);
+  virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot);
 
   virtual NS_HIDDEN_(nsresult) SetIsActive(bool aIsActive);
 
   virtual bool GetIsViewportOverridden() { return mViewportOverridden; }
 
   virtual bool IsLayoutFlushObserver()
   {
     return GetPresContext()->RefreshDriver()->
@@ -488,17 +488,17 @@ protected:
    * notified about.
    */
   void AddUserSheet(nsISupports* aSheet);
   void AddAgentSheet(nsISupports* aSheet);
   void AddAuthorSheet(nsISupports* aSheet);
   void RemoveSheet(nsStyleSet::sheetType aType, nsISupports* aSheet);
 
   // Hide a view if it is a popup
-  void HideViewIfPopup(nsIView* aView);
+  void HideViewIfPopup(nsView* aView);
 
   // Utility method to restore the root scrollframe state
   void RestoreRootScrollPosition();
 
   void MaybeReleaseCapturingContent()
   {
     nsRefPtr<nsFrameSelection> frameSelection = FrameSelection();
     if (frameSelection) {
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -18,17 +18,17 @@
 #include "nsIDOMElement.h"
 #include "nsIListControlFrame.h"
 #include "nsIDOMHTMLCollection.h"
 #include "nsIDOMHTMLSelectElement.h"
 #include "nsIDOMHTMLOptionElement.h"
 #include "nsPIDOMWindow.h"
 #include "nsIPresShell.h"
 #include "nsContentList.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsEventDispatcher.h"
 #include "nsEventListenerManager.h"
 #include "nsIDOMNode.h"
 #include "nsISelectControlFrame.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
 #include "nsIComponentManager.h"
@@ -137,43 +137,43 @@ public:
 
   explicit DestroyWidgetRunnable(nsIContent* aCombobox) :
     mCombobox(aCombobox),
     mWidget(GetWidget())
   {
   }
 
 private:
-  nsIWidget* GetWidget(nsIView** aOutView = nullptr) const;
+  nsIWidget* GetWidget(nsView** aOutView = nullptr) const;
 
 private:
   nsCOMPtr<nsIContent> mCombobox;
   nsIWidget* mWidget;
 };
 
 NS_IMETHODIMP DestroyWidgetRunnable::Run()
 {
-  nsIView* view = nullptr;
+  nsView* view = nullptr;
   nsIWidget* currentWidget = GetWidget(&view);
   // Make sure that we are destroying the same widget as what was requested
   // when the event was fired.
   if (view && mWidget && mWidget == currentWidget) {
     view->DestroyWidget();
   }
   return NS_OK;
 }
 
-nsIWidget* DestroyWidgetRunnable::GetWidget(nsIView** aOutView) const
+nsIWidget* DestroyWidgetRunnable::GetWidget(nsView** aOutView) const
 {
   nsIFrame* primaryFrame = mCombobox->GetPrimaryFrame();
   nsIComboboxControlFrame* comboboxFrame = do_QueryFrame(primaryFrame);
   if (comboboxFrame) {
     nsIFrame* dropdown = comboboxFrame->GetDropDown();
     if (dropdown) {
-      nsIView* view = dropdown->GetView();
+      nsView* view = dropdown->GetView();
       NS_ASSERTION(view, "nsComboboxControlFrame view is null");
       if (aOutView) {
         *aOutView = view;
       }
       if (view) {
         return view->GetWidget();
       }
     }
@@ -350,17 +350,17 @@ nsComboboxControlFrame::SetFocus(bool aO
   // rect to be drawn. This is much faster than ReResolvingStyle
   // Bug 32920
   InvalidateFrame();
 }
 
 void
 nsComboboxControlFrame::ShowPopup(bool aShowPopup)
 {
-  nsIView* view = mDropdownFrame->GetView();
+  nsView* view = mDropdownFrame->GetView();
   nsIViewManager* viewManager = view->GetViewManager();
 
   if (aShowPopup) {
     nsRect rect = mDropdownFrame->GetRect();
     rect.x = rect.y = 0;
     viewManager->ResizeView(view, rect);
     viewManager->SetViewVisibility(view, nsViewVisibility_kShow);
   } else {
@@ -383,17 +383,17 @@ nsComboboxControlFrame::ShowPopup(bool a
 bool
 nsComboboxControlFrame::ShowList(bool aShowList)
 {
   nsCOMPtr<nsIPresShell> shell = PresContext()->GetPresShell();
 
   nsWeakFrame weakFrame(this);
 
   if (aShowList) {
-    nsIView* view = mDropdownFrame->GetView();
+    nsView* view = mDropdownFrame->GetView();
     NS_ASSERTION(!view->HasWidget(),
                  "We shouldn't have a widget before we need to display the popup");
 
     // Create the widget for the drop-down list
     view->GetViewManager()->SetViewFloating(view, true);
 
     nsWidgetInitData widgetData;
     widgetData.mWindowType  = eWindowType_popup;
@@ -417,17 +417,17 @@ nsComboboxControlFrame::ShowList(bool aS
   // XXXbz so why do we need to flush here, exactly?
   shell->GetDocument()->FlushPendingNotifications(Flush_Layout);
   if (!weakFrame.IsAlive()) {
     return false;
   }
 
   nsIFrame* listFrame = do_QueryFrame(mListControlFrame);
   if (listFrame) {
-    nsIView* view = listFrame->GetView();
+    nsView* view = listFrame->GetView();
     NS_ASSERTION(view, "nsComboboxControlFrame view is null");
     if (view) {
       nsIWidget* widget = view->GetWidget();
       if (widget) {
         widget->CaptureRollupEvents(this, mDroppedDown);
 
         if (!aShowList) {
           nsCOMPtr<nsIRunnable> widgetDestroyer =
@@ -504,17 +504,17 @@ nsComboboxControlFrame::ReflowDropdown(n
   nscoord forcedWidth = aReflowState.ComputedWidth() +
     aReflowState.mComputedBorderPadding.LeftRight() -
     kidReflowState.mComputedBorderPadding.LeftRight();
   kidReflowState.SetComputedWidth(NS_MAX(kidReflowState.ComputedWidth(),
                                          forcedWidth));
 
   // ensure we start off hidden
   if (GetStateBits() & NS_FRAME_FIRST_REFLOW) {
-    nsIView* view = mDropdownFrame->GetView();
+    nsView* view = mDropdownFrame->GetView();
     nsIViewManager* viewManager = view->GetViewManager();
     viewManager->SetViewVisibility(view, nsViewVisibility_kHide);
     nsRect emptyRect(0, 0, 0, 0);
     viewManager->ResizeView(view, emptyRect);
   }
 
   // Allow the child to move/size/change-visibility its view if it's currently
   // dropped down
@@ -679,17 +679,17 @@ nsComboboxControlFrame::AbsolutelyPositi
 {
   nsPoint translation;
   nscoord above, below;
   mLastDropDownBelowScreenY = nscoord_MIN;
   GetAvailableDropdownSpace(&above, &below, &translation);
   if (above <= 0 && below <= 0) {
     if (IsDroppedDown()) {
       // Hide the view immediately to minimize flicker.
-      nsIView* view = mDropdownFrame->GetView();
+      nsView* view = mDropdownFrame->GetView();
       view->GetViewManager()->SetViewVisibility(view, nsViewVisibility_kHide);
       NS_DispatchToCurrentThread(new nsAsyncRollup(this));
     }
     return eDropDownPositionSuppressed;
   }
 
   nsSize dropdownSize = mDropdownFrame->GetSize();
   nscoord height = NS_MAX(above, below);
@@ -1452,17 +1452,17 @@ nsComboboxControlFrame::DestroyFrom(nsIF
   mRedisplayTextEvent.Revoke();
 
   nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
 
   if (mDroppedDown) {
     // Get parent view
     nsIFrame * listFrame = do_QueryFrame(mListControlFrame);
     if (listFrame) {
-      nsIView* view = listFrame->GetView();
+      nsView* view = listFrame->GetView();
       NS_ASSERTION(view, "nsComboboxControlFrame view is null");
       if (view) {
         nsIWidget* widget = view->GetWidget();
         if (widget)
           widget->CaptureRollupEvents(this, false);
       }
     }
   }
@@ -1535,17 +1535,17 @@ nsComboboxControlFrame::Rollup(uint32_t 
 
 nsIWidget*
 nsComboboxControlFrame::GetRollupWidget()
 {
   nsIFrame* listFrame = do_QueryFrame(mListControlFrame);
   if (!listFrame)
     return nullptr;
 
-  nsIView* view = listFrame->GetView();
+  nsView* view = listFrame->GetView();
   MOZ_ASSERT(view);
   return view->GetWidget();
 }
 
 void
 nsComboboxControlFrame::RollupFromList()
 {
   if (ShowList(false))
--- a/layout/forms/nsComboboxControlFrame.h
+++ b/layout/forms/nsComboboxControlFrame.h
@@ -30,17 +30,17 @@
 #include "nsIRollupListener.h"
 #include "nsPresState.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsIStatefulFrame.h"
 #include "nsIScrollableFrame.h"
 #include "nsIDOMEventListener.h"
 #include "nsThreadUtils.h"
 
-class nsIView;
+class nsView;
 class nsStyleContext;
 class nsIListControlFrame;
 class nsComboboxDisplayFrame;
 
 class nsComboboxControlFrame : public nsBlockFrame,
                                public nsIFormControlFrame,
                                public nsIComboboxControlFrame,
                                public nsIAnonymousContentCreator,
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -33,17 +33,17 @@
 
 #include "nsIContent.h"
 #include "nsIAtom.h"
 #include "nsPresContext.h"
 #include "nsRenderingContext.h"
 #include "nsGkAtoms.h"
 #include "nsLayoutUtils.h"
 #include "nsIComponentManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMHTMLElement.h"
 #include "nsIPresShell.h"
 
 #include "nsBoxLayoutState.h"
 //for keylistener for "return" check
--- a/layout/generic/nsAbsoluteContainingBlock.cpp
+++ b/layout/generic/nsAbsoluteContainingBlock.cpp
@@ -435,17 +435,17 @@ nsAbsoluteContainingBlock::ReflowAbsolut
   }
 
   // Position the child relative to our padding edge
   nsRect  rect(border.left + kidReflowState.mComputedOffsets.left + kidReflowState.mComputedMargin.left,
                border.top + kidReflowState.mComputedOffsets.top + kidReflowState.mComputedMargin.top,
                kidDesiredSize.width, kidDesiredSize.height);
   aKidFrame->SetRect(rect);
 
-  nsIView* view = aKidFrame->GetView();
+  nsView* view = aKidFrame->GetView();
   if (view) {
     // Size and position the view and set its opacity, visibility, content
     // transparency, and clip
     nsContainerFrame::SyncFrameViewAfterReflow(aPresContext, aKidFrame, view,
                                                kidDesiredSize.VisualOverflow());
   } else {
     nsContainerFrame::PositionChildViews(aKidFrame);
   }
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -22,17 +22,17 @@
 #include "nsInlineFrame.h"
 #include "nsLineLayout.h"
 #include "nsPlaceholderFrame.h"
 #include "nsStyleConsts.h"
 #include "nsFrameManager.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsStyleContext.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsHTMLParts.h"
 #include "nsGkAtoms.h"
 #include "nsIDOMEvent.h"
 #include "nsGenericHTMLElement.h"
 #include "nsAttrValueInlines.h"
 #include "prprf.h"
 #include "nsStyleChangeList.h"
 #include "nsFrameSelection.h"
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -11,17 +11,17 @@
 #include "nsIContent.h"
 #include "nsIDocument.h"
 #include "nsPresContext.h"
 #include "nsStyleContext.h"
 #include "nsRect.h"
 #include "nsPoint.h"
 #include "nsGUIEvent.h"
 #include "nsStyleConsts.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsFrameManager.h"
 #include "nsIPresShell.h"
 #include "nsCOMPtr.h"
 #include "nsGkAtoms.h"
 #include "nsCSSAnonBoxes.h"
 #include "nsIViewManager.h"
 #include "nsIWidget.h"
 #include "nsGfxCIID.h"
@@ -369,40 +369,40 @@ nsContainerFrame::PeekOffsetCharacter(bo
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Helper member functions
 
 static nsresult
 ReparentFrameViewTo(nsIFrame*       aFrame,
                     nsIViewManager* aViewManager,
-                    nsIView*        aNewParentView,
-                    nsIView*        aOldParentView)
+                    nsView*        aNewParentView,
+                    nsView*        aOldParentView)
 {
 
   // XXX What to do about placeholder views for "position: fixed" elements?
   // They should be reparented too.
 
   // Does aFrame have a view?
   if (aFrame->HasView()) {
 #ifdef MOZ_XUL
     if (aFrame->GetType() == nsGkAtoms::menuPopupFrame) {
       // This view must be parented by the root view, don't reparent it.
       return NS_OK;
     }
 #endif
-    nsIView* view = aFrame->GetView();
+    nsView* view = aFrame->GetView();
     // Verify that the current parent view is what we think it is
-    //nsIView*  parentView;
+    //nsView*  parentView;
     //NS_ASSERTION(parentView == aOldParentView, "unexpected parent view");
 
     aViewManager->RemoveChild(view);
     
     // The view will remember the Z-order and other attributes that have been set on it.
-    nsIView* insertBefore = nsLayoutUtils::FindSiblingViewFor(aNewParentView, aFrame);
+    nsView* insertBefore = nsLayoutUtils::FindSiblingViewFor(aNewParentView, aFrame);
     aViewManager->InsertChild(aNewParentView, view, insertBefore, insertBefore != nullptr);
   } else {
     nsIFrame::ChildListIterator lists(aFrame);
     for (; !lists.IsDone(); lists.Next()) {
       // Iterate the child frames, and check each child frame to see if it has
       // a view
       nsFrameList::Enumerator childFrames(lists.CurrentList());
       for (; !childFrames.AtEnd(); childFrames.Next()) {
@@ -424,30 +424,30 @@ nsContainerFrame::CreateViewForFrame(nsI
   }
 
   // If we don't yet have a view, see if we need a view
   if (!aForce && !aFrame->NeedsView()) {
     // don't need a view
     return NS_OK;
   }
 
-  nsIView* parentView = aFrame->GetParent()->GetClosestView();
+  nsView* parentView = aFrame->GetParent()->GetClosestView();
   NS_ASSERTION(parentView, "no parent with view");
 
   nsIViewManager* viewManager = parentView->GetViewManager();
   NS_ASSERTION(viewManager, "null view manager");
 
   // Create a view
-  nsIView* view = viewManager->CreateView(aFrame->GetRect(), parentView);
+  nsView* view = viewManager->CreateView(aFrame->GetRect(), parentView);
   if (!view)
     return NS_ERROR_OUT_OF_MEMORY;
 
   SyncFrameViewProperties(aFrame->PresContext(), aFrame, nullptr, view);
 
-  nsIView* insertBefore = nsLayoutUtils::FindSiblingViewFor(parentView, aFrame);
+  nsView* insertBefore = nsLayoutUtils::FindSiblingViewFor(parentView, aFrame);
   // we insert this view 'above' the insertBefore view, unless insertBefore is null,
   // in which case we want to call with aAbove == false to insert at the beginning
   // in document order
   viewManager->InsertChild(parentView, view, insertBefore, insertBefore != nullptr);
 
   // REVIEW: Don't create a widget for fixed-pos elements anymore.
   // ComputeRepaintRegionForCopy will calculate the right area to repaint
   // when we scroll.
@@ -474,20 +474,20 @@ nsContainerFrame::CreateViewForFrame(nsI
  */
 void
 nsContainerFrame::PositionFrameView(nsIFrame* aKidFrame)
 {
   nsIFrame* parentFrame = aKidFrame->GetParent();
   if (!aKidFrame->HasView() || !parentFrame)
     return;
 
-  nsIView* view = aKidFrame->GetView();
+  nsView* view = aKidFrame->GetView();
   nsIViewManager* vm = view->GetViewManager();
   nsPoint pt;
-  nsIView* ancestorView = parentFrame->GetClosestView(&pt);
+  nsView* ancestorView = parentFrame->GetClosestView(&pt);
 
   if (ancestorView != view->GetParent()) {
     NS_ASSERTION(ancestorView == view->GetParent()->GetParent(),
                  "Allowed only one anonymous view between frames");
     // parentFrame is responsible for positioning aKidFrame's view
     // explicitly
     return;
   }
@@ -535,18 +535,18 @@ nsContainerFrame::ReparentFrameView(nsPr
     // and the common parent or the new parent frame and the common parent.
     // Because neither the old parent frame nor the new parent frame have views,
     // then any child views don't need reparenting
     return NS_OK;
   }
 
   // We found views for one or both of the ancestor frames before we
   // found a common ancestor.
-  nsIView* oldParentView = aOldParentFrame->GetClosestView();
-  nsIView* newParentView = aNewParentFrame->GetClosestView();
+  nsView* oldParentView = aOldParentFrame->GetClosestView();
+  nsView* newParentView = aNewParentFrame->GetClosestView();
   
   // See if the old parent frame and the new parent frame are in the
   // same view sub-hierarchy. If they are then we don't have to do
   // anything
   if (oldParentView != newParentView) {
     // They're not so we need to reparent any child views
     return ReparentFrameViewTo(aChildFrame, oldParentView->GetViewManager(), newParentView,
                                oldParentView);
@@ -595,18 +595,18 @@ nsContainerFrame::ReparentFrameViewList(
     // and the common parent or the new parent frame and the common parent.
     // Because neither the old parent frame nor the new parent frame have views,
     // then any child views don't need reparenting
     return NS_OK;
   }
 
   // We found views for one or both of the ancestor frames before we
   // found a common ancestor.
-  nsIView* oldParentView = aOldParentFrame->GetClosestView();
-  nsIView* newParentView = aNewParentFrame->GetClosestView();
+  nsView* oldParentView = aOldParentFrame->GetClosestView();
+  nsView* newParentView = aNewParentFrame->GetClosestView();
   
   // See if the old parent frame and the new parent frame are in the
   // same view sub-hierarchy. If they are then we don't have to do
   // anything
   if (oldParentView != newParentView) {
     nsIViewManager* viewManager = oldParentView->GetViewManager();
 
     // They're not so we need to reparent any child views
@@ -640,29 +640,29 @@ IsTopLevelWidget(nsIWidget* aWidget)
          windowType == eWindowType_dialog ||
          windowType == eWindowType_sheet;
   // popups aren't toplevel so they're not handled here
 }
 
 void
 nsContainerFrame::SyncWindowProperties(nsPresContext*       aPresContext,
                                        nsIFrame*            aFrame,
-                                       nsIView*             aView,
+                                       nsView*             aView,
                                        nsRenderingContext*  aRC)
 {
 #ifdef MOZ_XUL
   if (!aView || !nsCSSRendering::IsCanvasFrame(aFrame) || !aView->HasWidget())
     return;
 
   nsIWidget* windowWidget = GetPresContextContainerWidget(aPresContext);
   if (!windowWidget || !IsTopLevelWidget(windowWidget))
     return;
 
   nsIViewManager* vm = aView->GetViewManager();
-  nsIView* rootView = vm->GetRootView();
+  nsView* rootView = vm->GetRootView();
 
   if (aView != rootView)
     return;
 
   Element* rootElement = aPresContext->Document()->GetRootElement();
   if (!rootElement || !rootElement->IsXUL()) {
     // Scrollframes use native widgets which don't work well with
     // translucent windows, at least in Windows XP. So if the document
@@ -729,17 +729,17 @@ void nsContainerFrame::SetSizeConstraint
     constraints.mMaxSize.height += windowSize.height - 200;
 
   aWidget->SetSizeConstraints(constraints);
 }
 
 void
 nsContainerFrame::SyncFrameViewAfterReflow(nsPresContext* aPresContext,
                                            nsIFrame*       aFrame,
-                                           nsIView*        aView,
+                                           nsView*        aView,
                                            const nsRect&   aVisualOverflowArea,
                                            uint32_t        aFlags)
 {
   if (!aView) {
     return;
   }
 
   // Make sure the view is sized and positioned correctly
@@ -753,17 +753,17 @@ nsContainerFrame::SyncFrameViewAfterRefl
     vm->ResizeView(aView, aVisualOverflowArea, true);
   }
 }
 
 void
 nsContainerFrame::SyncFrameViewProperties(nsPresContext*  aPresContext,
                                           nsIFrame*        aFrame,
                                           nsStyleContext*  aStyleContext,
-                                          nsIView*         aView,
+                                          nsView*         aView,
                                           uint32_t         aFlags)
 {
   NS_ASSERTION(!aStyleContext || aFrame->GetStyleContext() == aStyleContext,
                "Wrong style context for frame?");
 
   if (!aView) {
     return;
   }
@@ -1031,17 +1031,17 @@ nsContainerFrame::FinishReflowChild(nsIF
                                     uint32_t                   aFlags)
 {
   nsPoint curOrigin = aKidFrame->GetPosition();
   nsRect  bounds(aX, aY, aDesiredSize.width, aDesiredSize.height);
 
   aKidFrame->SetRect(bounds);
 
   if (aKidFrame->HasView()) {
-    nsIView* view = aKidFrame->GetView();
+    nsView* view = aKidFrame->GetView();
     // Make sure the frame's view is properly sized and positioned and has
     // things like opacity correct
     SyncFrameViewAfterReflow(aPresContext, aKidFrame, view,
                              aDesiredSize.VisualOverflow(), aFlags);
   }
 
   if (!(aFlags & NS_FRAME_NO_MOVE_VIEW) &&
       (curOrigin.x != aX || curOrigin.y != aY)) {
--- a/layout/generic/nsContainerFrame.h
+++ b/layout/generic/nsContainerFrame.h
@@ -129,37 +129,37 @@ public:
   // Set the view's size and position after its frame has been reflowed.
   //
   // Flags:
   // NS_FRAME_NO_MOVE_VIEW - don't position the frame's view. Set this if you
   //    don't want to automatically sync the frame and view
   // NS_FRAME_NO_SIZE_VIEW - don't size the view
   static void SyncFrameViewAfterReflow(nsPresContext* aPresContext,
                                        nsIFrame*       aFrame,
-                                       nsIView*        aView,
+                                       nsView*        aView,
                                        const nsRect&   aVisualOverflowArea,
                                        uint32_t        aFlags = 0);
 
   // Syncs properties to the top level view and window, like transparency and
   // shadow.
   static void SyncWindowProperties(nsPresContext*       aPresContext,
                                    nsIFrame*            aFrame,
-                                   nsIView*             aView,
+                                   nsView*             aView,
                                    nsRenderingContext*  aRC = nullptr);
 
   // Sets the view's attributes from the frame style.
   // - visibility
   // - clip
   // Call this when one of these styles changes or when the view has just
   // been created.
   // @param aStyleContext can be null, in which case the frame's style context is used
   static void SyncFrameViewProperties(nsPresContext*  aPresContext,
                                       nsIFrame*        aFrame,
                                       nsStyleContext*  aStyleContext,
-                                      nsIView*         aView,
+                                      nsView*         aView,
                                       uint32_t         aFlags = 0);
 
   /**
    * Converts the minimum and maximum sizes given in inner window app units to
    * outer window device pixel sizes and assigns these constraints to the widget.
    *
    * @param aPresContext pres context
    * @param aWidget widget for this frame
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -16,17 +16,17 @@
 #include "nsLineLayout.h"
 #include "nsIContent.h"
 #include "nsContentUtils.h"
 #include "nsIAtom.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsStyleContext.h"
 #include "nsTableOuterFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIScrollableFrame.h"
 #include "nsPresContext.h"
 #include "nsCRT.h"
 #include "nsGUIEvent.h"
 #include "nsIDOMEvent.h"
 #include "nsAsyncDOMEvent.h"
 #include "nsStyleConsts.h"
@@ -296,17 +296,17 @@ bool
 nsIFrame::IsVisibleConsideringAncestors(uint32_t aFlags) const
 {
   if (!GetStyleVisibility()->IsVisible()) {
     return false;
   }
 
   const nsIFrame* frame = this;
   while (frame) {
-    nsIView* view = frame->GetView();
+    nsView* view = frame->GetView();
     if (view && view->GetVisibility() == nsViewVisibility_kHide)
       return false;
     
     nsIFrame* parent = frame->GetParent();
     nsDeckFrame* deck = do_QueryFrame(parent);
     if (deck) {
       if (deck->GetSelectedBox() != frame)
         return false;
@@ -600,17 +600,17 @@ nsFrame::DestroyFrom(nsIFrame* aDestruct
                "Frames should be removed before destruction.");
   NS_ASSERTION(aDestructRoot, "Must specify destruct root");
   MOZ_ASSERT(!HasAbsolutelyPositionedChildren());
 
   nsSVGEffects::InvalidateDirectRenderingObservers(this);
 
   // Get the view pointer now before the frame properties disappear
   // when we call NotifyDestroyingFrame()
-  nsIView* view = GetView();
+  nsView* view = GetView();
   nsPresContext* presContext = PresContext();
 
   nsIPresShell *shell = presContext->GetPresShell();
   if (mState & NS_FRAME_OUT_OF_FLOW) {
     nsPlaceholderFrame* placeholder =
       shell->FrameManager()->GetPlaceholderFrameFor(this);
     NS_ASSERTION(!placeholder || (aDestructRoot != this),
                  "Don't call Destroy() on OOFs, call Destroy() on the placeholder.");
@@ -4369,37 +4369,37 @@ nsIFrame* nsIFrame::GetTailContinuation(
   }
   NS_POSTCONDITION(frame, "illegal state in continuation chain.");
   return frame;
 }
 
 NS_DECLARE_FRAME_PROPERTY(ViewProperty, nullptr)
 
 // Associated view object
-nsIView*
+nsView*
 nsIFrame::GetView() const
 {
   // Check the frame state bit and see if the frame has a view
   if (!(GetStateBits() & NS_FRAME_HAS_VIEW))
     return nullptr;
 
   // Check for a property on the frame
   void* value = Properties().Get(ViewProperty());
   NS_ASSERTION(value, "frame state bit was set but frame has no view");
-  return static_cast<nsIView*>(value);
-}
-
-/* virtual */ nsIView*
+  return static_cast<nsView*>(value);
+}
+
+/* virtual */ nsView*
 nsIFrame::GetViewExternal() const
 {
   return GetView();
 }
 
 nsresult
-nsIFrame::SetView(nsIView* aView)
+nsIFrame::SetView(nsView* aView)
 {
   if (aView) {
     aView->SetFrame(this);
 
     // Set a property on the frame
     Properties().Set(ViewProperty(), aView);
 
     // Set the frame state bit that says the frame has a view
@@ -4571,17 +4571,17 @@ nsRect nsIFrame::GetScreenRectInAppUnits
   }
 
   return nsRect(rootScreenPos + GetOffsetTo(rootFrame), GetSize());
 }
 
 // Returns the offset from this frame to the closest geometric parent that
 // has a view. Also returns the containing view or null in case of error
 NS_IMETHODIMP nsFrame::GetOffsetFromView(nsPoint&  aOffset,
-                                         nsIView** aView) const
+                                         nsView** aView) const
 {
   NS_PRECONDITION(nullptr != aView, "null OUT parameter pointer");
   nsIFrame* frame = (nsIFrame*)this;
 
   *aView = nullptr;
   aOffset.MoveTo(0, 0);
   do {
     aOffset += frame->GetPosition();
@@ -5277,17 +5277,17 @@ nsFrame::UpdateOverflow()
   nsOverflowAreas overflowAreas(rect, rect);
 
   bool isBox = IsBoxFrame() || IsBoxWrapped();
   if (!isBox || (!IsCollapsed() && !DoesClipChildren())) {
     nsLayoutUtils::UnionChildOverflow(this, overflowAreas);
   }
 
   if (FinishAndStoreOverflow(overflowAreas, GetSize())) {
-    nsIView* view = GetView();
+    nsView* view = GetView();
     if (view) {
       uint32_t flags = 0;
       GetLayoutFlags(flags);
 
       if ((flags & NS_FRAME_NO_SIZE_VIEW) == 0) {
         // Make sure the frame's view is properly sized.
         nsIViewManager* vm = view->GetViewManager();
         vm->ResizeView(view, overflowAreas.VisualOverflow(), true);
@@ -5836,17 +5836,17 @@ nsFrame::GetNextPrevLineFromeBlockFrame(
         nearStoppingFrame = firstFrame;
         farStoppingFrame = lastFrame;
       }
       else{
         nearStoppingFrame = lastFrame;
         farStoppingFrame = firstFrame;
       }
       nsPoint offset;
-      nsIView * view; //used for call of get offset from view
+      nsView * view; //used for call of get offset from view
       aBlockFrame->GetOffsetFromView(offset,&view);
       nscoord newDesiredX  = aPos->mDesiredX - offset.x;//get desired x into blockframe coordinates!
       result = it->FindFrameAt(searchingLine, newDesiredX, &resultFrame, &isBeforeFirstFrame, &isAfterLastFrame);
       if(NS_FAILED(result))
         continue;
     }
 
     if (NS_SUCCEEDED(result) && resultFrame)
@@ -5874,17 +5874,17 @@ nsFrame::GetNextPrevLineFromeBlockFrame(
 
       nsIFrame *storeOldResultFrame = resultFrame;
       while ( !found ){
         nsPoint point;
         point.x = aPos->mDesiredX;
 
         nsRect tempRect = resultFrame->GetRect();
         nsPoint offset;
-        nsIView * view; //used for call of get offset from view
+        nsView * view; //used for call of get offset from view
         result = resultFrame->GetOffsetFromView(offset, &view);
         if (NS_FAILED(result))
           return result;
         point.y = tempRect.height + offset.y;
 
         //special check. if we allow non-text selection then we can allow a hit location to fall before a table.
         //otherwise there is no way to get and click signal to fall before a table (it being a line iterator itself)
         nsIPresShell *shell = aPresContext->GetPresShell();
@@ -5918,17 +5918,17 @@ nsFrame::GetNextPrevLineFromeBlockFrame(
                 }
               }
             }
           }
         }
 
         if (!resultFrame->HasView())
         {
-          nsIView* view;
+          nsView* view;
           nsPoint offset;
           resultFrame->GetOffsetFromView(offset, &view);
           ContentOffsets offsets =
               resultFrame->GetContentOffsetsFromPoint(point - offset);
           aPos->mResultContent = offsets.content;
           aPos->mContentOffset = offsets.offset;
           aPos->mAttachForward = offsets.associateWithNext;
           if (offsets.content)
@@ -5962,17 +5962,17 @@ nsFrame::GetNextPrevLineFromeBlockFrame(
                                       eLeaf,
                                       false, // aVisual
                                       aPos->mScrollViewStop,
                                       false     // aFollowOOFs
                                       );
       }
       while ( !found ){
         nsPoint point(aPos->mDesiredX, 0);
-        nsIView* view;
+        nsView* view;
         nsPoint offset;
         resultFrame->GetOffsetFromView(offset, &view);
         ContentOffsets offsets =
             resultFrame->GetContentOffsetsFromPoint(point - offset);
         aPos->mResultContent = offsets.content;
         aPos->mContentOffset = offsets.offset;
         aPos->mAttachForward = offsets.associateWithNext;
         if (offsets.content)
@@ -6750,17 +6750,17 @@ nsIFrame::GetFrameFromDirection(nsDirect
     if ((newLevel & 1) != (newBaseLevel & 1)) // The new frame is reverse-direction, go to the other end
       *aOutOffset = -1 - *aOutOffset;
   }
 #endif
   *aOutFrame = traversedFrame;
   return NS_OK;
 }
 
-nsIView* nsIFrame::GetClosestView(nsPoint* aOffset) const
+nsView* nsIFrame::GetClosestView(nsPoint* aOffset) const
 {
   nsPoint offset(0,0);
   for (const nsIFrame *f = this; f; f = f->GetParent()) {
     if (f->HasView()) {
       if (aOffset)
         *aOffset = offset;
       return f->GetView();
     }
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -194,17 +194,17 @@ public:
   virtual nsIFrame* GetPrevContinuation() const;
   NS_IMETHOD  SetPrevContinuation(nsIFrame*);
   virtual nsIFrame* GetNextContinuation() const;
   NS_IMETHOD  SetNextContinuation(nsIFrame*);
   virtual nsIFrame* GetPrevInFlowVirtual() const;
   NS_IMETHOD  SetPrevInFlow(nsIFrame*);
   virtual nsIFrame* GetNextInFlowVirtual() const;
   NS_IMETHOD  SetNextInFlow(nsIFrame*);
-  NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsIView** aView) const;
+  NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsView** aView) const;
   virtual nsIAtom* GetType() const;
 
   NS_IMETHOD  IsSelectable(bool* aIsSelectable, uint8_t* aSelectStyle) const;
 
   NS_IMETHOD  GetSelectionController(nsPresContext *aPresContext, nsISelectionController **aSelCon);
 
   virtual bool PeekOffsetNoAmount(bool aForward, int32_t* aOffset);
   virtual bool PeekOffsetCharacter(bool aForward, int32_t* aOffset,
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -16,17 +16,17 @@
 #include "nsContainerFrame.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsIComponentManager.h"
 #include "nsIStreamListener.h"
 #include "nsIURL.h"
 #include "nsIDocument.h"
 #include "nsINodeInfo.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsWidgetsCID.h"
 #include "nsGkAtoms.h"
 #include "nsStyleCoord.h"
 #include "nsStyleConsts.h"
 #include "nsStyleContext.h"
 #include "nsHTMLParts.h"
 #include "nsGUIEvent.h"
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* rendering object to wrap rendering objects that should be scrollable */
 
 #include "nsCOMPtr.h"
 #include "nsHTMLParts.h"
 #include "nsPresContext.h"
 #include "nsIServiceManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIScrollable.h"
 #include "nsIViewManager.h"
 #include "nsContainerFrame.h"
 #include "nsGfxScrollFrame.h"
 #include "nsGkAtoms.h"
 #include "nsINameSpaceManager.h"
 #include "nsContentList.h"
 #include "nsIDocument.h"
@@ -1628,17 +1628,17 @@ nsGfxScrollFrameInner::ScrollToWithOrigi
     mAsyncScroll->Init(range);
   }
 }
 
 // We can't use nsContainerFrame::PositionChildViews here because
 // we don't want to invalidate views that have moved.
 static void AdjustViews(nsIFrame* aFrame)
 {
-  nsIView* view = aFrame->GetView();
+  nsView* view = aFrame->GetView();
   if (view) {
     nsPoint pt;
     aFrame->GetParent()->GetClosestView(&pt);
     pt += aFrame->GetPosition();
     view->SetPosition(pt.x, pt.y);
 
     return;
   }
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -57,17 +57,17 @@
 struct nsHTMLReflowState;
 class nsHTMLReflowCommand;
 
 struct gfxMatrix;
 class nsIAtom;
 class nsPresContext;
 class nsIPresShell;
 class nsRenderingContext;
-class nsIView;
+class nsView;
 class nsIWidget;
 class nsIDOMRange;
 class nsISelectionController;
 class nsBoxLayoutState;
 class nsBoxLayout;
 class nsILineIterator;
 class nsDisplayListBuilder;
 class nsDisplayListSet;
@@ -1944,26 +1944,26 @@ public:
   { return false; }
 
   /**
    * Accessor functions to get/set the associated view object
    *
    * GetView returns non-null if and only if |HasView| returns true.
    */
   bool HasView() const { return !!(mState & NS_FRAME_HAS_VIEW); }
-  nsIView* GetView() const;
-  virtual nsIView* GetViewExternal() const;
-  nsresult SetView(nsIView* aView);
+  nsView* GetView() const;
+  virtual nsView* GetViewExternal() const;
+  nsresult SetView(nsView* aView);
 
   /**
    * Find the closest view (on |this| or an ancestor).
    * If aOffset is non-null, it will be set to the offset of |this|
    * from the returned view.
    */
-  nsIView* GetClosestView(nsPoint* aOffset = nullptr) const;
+  nsView* GetClosestView(nsPoint* aOffset = nullptr) const;
 
   /**
    * Find the closest ancestor (excluding |this| !) that has a view
    */
   nsIFrame* GetAncestorWithView() const;
   virtual nsIFrame* GetAncestorWithViewExternal() const;
 
   /**
@@ -2021,17 +2021,17 @@ public:
   nsRect GetScreenRectInAppUnits() const;
   virtual nsRect GetScreenRectInAppUnitsExternal() const;
 
   /**
    * Returns the offset from this frame to the closest geometric parent that
    * has a view. Also returns the containing view or null in case of error
    */
   NS_IMETHOD  GetOffsetFromView(nsPoint&  aOffset,
-                                nsIView** aView) const = 0;
+                                nsView** aView) const = 0;
 
   /**
    * Returns the nearest widget containing this frame. If this frame has a
    * view and the view has a widget, then this frame's widget is
    * returned, otherwise this frame's geometric parent is checked
    * recursively upwards.
    * XXX virtual because gfx callers use it! (themes)
    */
--- a/layout/generic/nsObjectFrame.cpp
+++ b/layout/generic/nsObjectFrame.cpp
@@ -8,17 +8,17 @@
 
 #include "mozilla/plugins/PluginMessageUtils.h"
 
 #include "nscore.h"
 #include "nsCOMPtr.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsWidgetsCID.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsIDOMEventListener.h"
 #include "nsIDOMDragEvent.h"
 #include "nsPluginHost.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsGkAtoms.h"
 #include "nsIAppShell.h"
@@ -323,17 +323,17 @@ nsObjectFrame::DestroyFrom(nsIFrame* aDe
 
   nsObjectFrameSuper::DestroyFrom(aDestructRoot);
 }
 
 /* virtual */ void
 nsObjectFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
 {
   if (HasView()) {
-    nsIView* view = GetView();
+    nsView* view = GetView();
     nsIViewManager* vm = view->GetViewManager();
     if (vm) {
       nsViewVisibility visibility = 
         IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow;
       vm->SetViewVisibility(view, visibility);
     }
   }
 
@@ -354,32 +354,32 @@ nsObjectFrame::GetFrameName(nsAString& a
 }
 #endif
 
 nsresult
 nsObjectFrame::PrepForDrawing(nsIWidget *aWidget)
 {
   mWidget = aWidget;
 
-  nsIView* view = GetView();
+  nsView* view = GetView();
   NS_ASSERTION(view, "Object frames must have views");  
   if (!view) {
     return NS_ERROR_FAILURE;
   }
 
   nsIViewManager* viewMan = view->GetViewManager();
   // mark the view as hidden since we don't know the (x,y) until Paint
   // XXX is the above comment correct?
   viewMan->SetViewVisibility(view, nsViewVisibility_kHide);
 
   //this is ugly. it was ripped off from didreflow(). MMP
   // Position and size view relative to its parent, not relative to our
   // parent frame (our parent frame may not have a view).
   
-  nsIView* parentWithView;
+  nsView* parentWithView;
   nsPoint origin;
   nsRect r(0, 0, mRect.width, mRect.height);
 
   GetOffsetFromView(origin, &parentWithView);
   viewMan->ResizeView(view, r);
   viewMan->MoveViewTo(view, origin.x, origin.y);
 
   nsPresContext* presContext = PresContext();
@@ -838,17 +838,17 @@ nsObjectFrame::IsHidden(bool aCheckVisib
     }
   }
 
   return false;
 }
 
 nsIntPoint nsObjectFrame::GetWindowOriginInPixels(bool aWindowless)
 {
-  nsIView * parentWithView;
+  nsView * parentWithView;
   nsPoint origin(0,0);
 
   GetOffsetFromView(origin, &parentWithView);
 
   // if it's windowless, let's make sure we have our origin set right
   // it may need to be corrected, like after scrolling
   if (aWindowless && parentWithView) {
     nsPoint offsetToWidget;
@@ -878,17 +878,17 @@ nsObjectFrame::DidReflow(nsPresContext* 
   nsresult rv = nsObjectFrameSuper::DidReflow(aPresContext, aReflowState, aStatus);
 
   // The view is created hidden; once we have reflowed it and it has been
   // positioned then we show it.
   if (aStatus != nsDidReflowStatus::FINISHED) 
     return rv;
 
   if (HasView()) {
-    nsIView* view = GetView();
+    nsView* view = GetView();
     nsIViewManager* vm = view->GetViewManager();
     if (vm)
       vm->SetViewVisibility(view, IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow);
   }
 
   return rv;
 }
 
--- a/layout/generic/nsObjectFrame.h
+++ b/layout/generic/nsObjectFrame.h
@@ -261,17 +261,17 @@ private:
       mEventType(aEventType) {}
     
     NS_IMETHOD Run();
   private:
     nsString mEventType;
   };
 
   nsPluginInstanceOwner*          mInstanceOwner; // WEAK
-  nsIView*                        mInnerView;
+  nsView*                        mInnerView;
   nsCOMPtr<nsIWidget>             mWidget;
   nsIntRect                       mWindowlessRect;
   /**
    * This is owned by the ReadbackLayer for this nsObjectFrame. It is
    * automatically cleared if the PluginBackgroundSink is destroyed.
    */
   PluginBackgroundSink*           mBackgroundSink;
 
--- a/layout/generic/nsSelection.cpp
+++ b/layout/generic/nsSelection.cpp
@@ -562,17 +562,17 @@ nsFrameSelection::FetchDesiredX(nscoord 
   if (NS_FAILED(result))
     return result;
 
   nsRect coord;
   nsIFrame* caretFrame = caret->GetGeometry(mDomSelections[index], &coord);
   if (!caretFrame)
     return NS_ERROR_FAILURE;
   nsPoint viewOffset(0, 0);
-  nsIView* view = nullptr;
+  nsView* view = nullptr;
   caretFrame->GetOffsetFromView(viewOffset, &view);
   if (view)
     coord.x += viewOffset.x;
 
   aDesiredX = coord.x;
   return NS_OK;
 }
 
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -24,17 +24,17 @@
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsIComponentManager.h"
 #include "nsFrameManager.h"
 #include "nsIStreamListener.h"
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 #include "nsIDocument.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsGkAtoms.h"
 #include "nsStyleCoord.h"
 #include "nsStyleContext.h"
 #include "nsStyleConsts.h"
 #include "nsFrameSetFrame.h"
 #include "nsIDOMHTMLFrameElement.h"
 #include "nsIDOMHTMLIFrameElement.h"
@@ -56,17 +56,17 @@
 #include "nsContentUtils.h"
 #include "LayerTreeInvalidation.h"
 #include "nsIPermissionManager.h"
 
 using namespace mozilla;
 using mozilla::layout::RenderFrameParent;
 
 static nsIDocument*
-GetDocumentFromView(nsIView* aView)
+GetDocumentFromView(nsView* aView)
 {
   NS_PRECONDITION(aView, "");
 
   nsIFrame* f = aView->GetFrame();
   nsIPresShell* ps =  f ? f->PresContext()->PresShell() : nullptr;
   return ps ? ps->GetDocument() : nullptr;
 }
 
@@ -104,20 +104,20 @@ public:
     }
     return NS_OK;
   }
 private:
   nsWeakFrame mFrame;
 };
 
 static void
-InsertViewsInReverseOrder(nsIView* aSibling, nsIView* aParent);
+InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent);
 
 static void
-EndSwapDocShellsForViews(nsIView* aView);
+EndSwapDocShellsForViews(nsView* aView);
 
 NS_IMETHODIMP
 nsSubDocumentFrame::Init(nsIContent*     aContent,
                          nsIFrame*       aParent,
                          nsIFrame*       aPrevInFlow)
 {
   // determine if we are a <frame> or <iframe>
   if (aContent) {
@@ -149,17 +149,17 @@ nsSubDocumentFrame::Init(nsIContent*    
 
   // If we have a detached subdoc's root view on our frame loader, re-insert
   // it into the view tree. This happens when we've been reframed, and
   // ensures the presentation persists across reframes. If the frame element
   // has changed documents however, we blow away the presentation.
   nsRefPtr<nsFrameLoader> frameloader = FrameLoader();
   if (frameloader) {
     nsCOMPtr<nsIDocument> oldContainerDoc;
-    nsIView* detachedViews =
+    nsView* detachedViews =
       frameloader->GetDetachedSubdocView(getter_AddRefs(oldContainerDoc));
     if (detachedViews) {
       if (oldContainerDoc == aContent->OwnerDoc()) {
         // Restore stashed presentation.
         ::InsertViewsInReverseOrder(detachedViews, mInnerView);
         ::EndSwapDocShellsForViews(mInnerView->GetFirstChild());
       } else {
         // Presentation is for a different document, don't restore it.
@@ -227,17 +227,17 @@ nsSubDocumentFrame::GetSkipSides() const
   return 0;
 }
 
 nsIFrame*
 nsSubDocumentFrame::GetSubdocumentRootFrame()
 {
   if (!mInnerView)
     return nullptr;
-  nsIView* subdocView = mInnerView->GetFirstChild();
+  nsView* subdocView = mInnerView->GetFirstChild();
   return subdocView ? subdocView->GetFrame() : nullptr;
 }
 
 bool
 nsSubDocumentFrame::PassPointerEventsToChildren()
 {
   if (GetStyleVisibility()->mPointerEvents != NS_STYLE_POINTER_EVENTS_NONE) {
     return true;
@@ -288,34 +288,34 @@ nsSubDocumentFrame::BuildDisplayList(nsD
   nsFrameLoader* frameLoader = FrameLoader();
   if (frameLoader) {
     RenderFrameParent* rfp = frameLoader->GetCurrentRemoteFrame();
     if (rfp) {
       return rfp->BuildDisplayList(aBuilder, this, aDirtyRect, aLists);
     }
   }
 
-  nsIView* subdocView = mInnerView->GetFirstChild();
+  nsView* subdocView = mInnerView->GetFirstChild();
   if (!subdocView)
     return NS_OK;
 
   nsCOMPtr<nsIPresShell> presShell = nullptr;
 
   nsIFrame* subdocRootFrame = subdocView->GetFrame();
   if (subdocRootFrame) {
     presShell = subdocRootFrame->PresContext()->PresShell();
   }
   // If painting is suppressed in the presshell, we try to look for a better
   // presshell to use.
   if (!presShell || (presShell->IsPaintingSuppressed() &&
                      !aBuilder->IsIgnoringPaintSuppression())) {
     // During page transition mInnerView will sometimes have two children, the
     // first being the new page that may not have any frame, and the second
     // being the old page that will probably have a frame.
-    nsIView* nextView = subdocView->GetNextSibling();
+    nsView* nextView = subdocView->GetNextSibling();
     nsIFrame* frame = nullptr;
     if (nextView) {
       frame = nextView->GetFrame();
     }
     if (frame) {
       nsIPresShell* ps = frame->PresContext()->PresShell();
       if (!presShell || (ps && !ps->IsPaintingSuppressed())) {
         subdocView = nextView;
@@ -822,33 +822,33 @@ public:
   }
 private:
   nsCOMPtr<nsIContent> mFrameElement;
   nsRefPtr<nsFrameLoader> mFrameLoader;
   nsCOMPtr<nsIPresShell> mPresShell;
   bool mHideViewerIfFrameless;
 };
 
-static nsIView*
-BeginSwapDocShellsForViews(nsIView* aSibling);
+static nsView*
+BeginSwapDocShellsForViews(nsView* aSibling);
 
 void
 nsSubDocumentFrame::DestroyFrom(nsIFrame* aDestructRoot)
 {
   if (mPostedReflowCallback) {
     PresContext()->PresShell()->CancelReflowCallback(this);
     mPostedReflowCallback = false;
   }
 
   // Detach the subdocument's views and stash them in the frame loader.
   // We can then reattach them if we're being reframed (for example if
   // the frame has been made position:fixed).
   nsFrameLoader* frameloader = FrameLoader();
   if (frameloader) {
-    nsIView* detachedViews = ::BeginSwapDocShellsForViews(mInnerView->GetFirstChild());
+    nsView* detachedViews = ::BeginSwapDocShellsForViews(mInnerView->GetFirstChild());
     frameloader->SetDetachedSubdocView(detachedViews, mContent->OwnerDoc());
 
     // We call nsFrameLoader::HideViewer() in a script runner so that we can
     // safely determine whether the frame is being reframed or destroyed.
     nsContentUtils::AddScriptRunner(
       new nsHideViewer(mContent,
                        mFrameLoader,
                        PresContext()->PresShell(),
@@ -928,44 +928,44 @@ BeginSwapDocShellsForDocument(nsIDocumen
     ::DestroyDisplayItemDataForFrames(rootFrame);
   }
   aDocument->EnumerateFreezableElements(
     nsObjectFrame::BeginSwapDocShells, nullptr);
   aDocument->EnumerateSubDocuments(BeginSwapDocShellsForDocument, nullptr);
   return true;
 }
 
-static nsIView*
-BeginSwapDocShellsForViews(nsIView* aSibling)
+static nsView*
+BeginSwapDocShellsForViews(nsView* aSibling)
 {
   // Collect the removed sibling views in reverse order in 'removedViews'.
-  nsIView* removedViews = nullptr;
+  nsView* removedViews = nullptr;
   while (aSibling) {
     nsIDocument* doc = ::GetDocumentFromView(aSibling);
     if (doc) {
       ::BeginSwapDocShellsForDocument(doc, nullptr);
     }
-    nsIView* next = aSibling->GetNextSibling();
+    nsView* next = aSibling->GetNextSibling();
     aSibling->GetViewManager()->RemoveChild(aSibling);
     aSibling->SetNextSibling(removedViews);
     removedViews = aSibling;
     aSibling = next;
   }
   return removedViews;
 }
 
 static void
-InsertViewsInReverseOrder(nsIView* aSibling, nsIView* aParent)
+InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent)
 {
   NS_PRECONDITION(aParent, "");
   NS_PRECONDITION(!aParent->GetFirstChild(), "inserting into non-empty list");
 
   nsIViewManager* vm = aParent->GetViewManager();
   while (aSibling) {
-    nsIView* next = aSibling->GetNextSibling();
+    nsView* next = aSibling->GetNextSibling();
     aSibling->SetNextSibling(nullptr);
     // true means 'after' in document order which is 'before' in view order,
     // so this call prepends the child, thus reversing the siblings as we go.
     vm->InsertChild(aParent, aSibling, nullptr, true);
     aSibling = next;
   }
 }
 
@@ -981,20 +981,20 @@ nsSubDocumentFrame::BeginSwapDocShells(n
       !other->mFrameLoader || !other->mDidCreateDoc) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   NS_ASSERTION(HasAnyStateBits(NS_FRAME_IN_POPUP) == other->HasAnyStateBits(NS_FRAME_IN_POPUP),
                "Can't swap doc shells when only one is within a popup!");
 
   if (mInnerView && other->mInnerView) {
-    nsIView* ourSubdocViews = mInnerView->GetFirstChild();
-    nsIView* ourRemovedViews = ::BeginSwapDocShellsForViews(ourSubdocViews);
-    nsIView* otherSubdocViews = other->mInnerView->GetFirstChild();
-    nsIView* otherRemovedViews = ::BeginSwapDocShellsForViews(otherSubdocViews);
+    nsView* ourSubdocViews = mInnerView->GetFirstChild();
+    nsView* ourRemovedViews = ::BeginSwapDocShellsForViews(ourSubdocViews);
+    nsView* otherSubdocViews = other->mInnerView->GetFirstChild();
+    nsView* otherRemovedViews = ::BeginSwapDocShellsForViews(otherSubdocViews);
 
     ::InsertViewsInReverseOrder(ourRemovedViews, other->mInnerView);
     ::InsertViewsInReverseOrder(otherRemovedViews, mInnerView);
   }
   mFrameLoader.swap(other->mFrameLoader);
   return NS_OK;
 }
 
@@ -1011,33 +1011,33 @@ EndSwapDocShellsForDocument(nsIDocument*
   if (ds) {
     nsCOMPtr<nsIContentViewer> cv;
     ds->GetContentViewer(getter_AddRefs(cv));
     while (cv) {
       nsCOMPtr<nsPresContext> pc;
       cv->GetPresContext(getter_AddRefs(pc));
       nsDeviceContext* dc = pc ? pc->DeviceContext() : nullptr;
       if (dc) {
-        nsIView* v = cv->FindContainerView();
+        nsView* v = cv->FindContainerView();
         dc->Init(v ? v->GetNearestWidget(nullptr) : nullptr);
       }
       nsCOMPtr<nsIContentViewer> prev;
       cv->GetPreviousViewer(getter_AddRefs(prev));
       cv = prev;
     }
   }
 
   aDocument->EnumerateFreezableElements(
     nsObjectFrame::EndSwapDocShells, nullptr);
   aDocument->EnumerateSubDocuments(EndSwapDocShellsForDocument, nullptr);
   return true;
 }
 
 static void
-EndSwapDocShellsForViews(nsIView* aSibling)
+EndSwapDocShellsForViews(nsView* aSibling)
 {
   for ( ; aSibling; aSibling = aSibling->GetNextSibling()) {
     nsIDocument* doc = ::GetDocumentFromView(aSibling);
     if (doc) {
       ::EndSwapDocShellsForDocument(doc, nullptr);
     }
     nsIFrame *frame = aSibling->GetFrame();
     if (frame && frame->HasInvalidFrameInSubtree()) {
@@ -1075,30 +1075,30 @@ nsSubDocumentFrame::EndSwapDocShells(nsI
   }
   if (weakOther.IsAlive()) {
     other->PresContext()->PresShell()->
       FrameNeedsReflow(other, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);
     other->InvalidateFrameSubtree();
   }
 }
 
-nsIView*
+nsView*
 nsSubDocumentFrame::EnsureInnerView()
 {
   if (mInnerView) {
     return mInnerView;
   }
 
   // create, init, set the parent of the view
-  nsIView* outerView = GetView();
+  nsView* outerView = GetView();
   NS_ASSERTION(outerView, "Must have an outer view already");
   nsRect viewBounds(0, 0, 0, 0); // size will be fixed during reflow
 
   nsIViewManager* viewMan = outerView->GetViewManager();
-  nsIView* innerView = viewMan->CreateView(viewBounds, outerView);
+  nsView* innerView = viewMan->CreateView(viewBounds, outerView);
   if (!innerView) {
     NS_ERROR("Could not create inner view");
     return nullptr;
   }
   mInnerView = innerView;
   viewMan->InsertChild(outerView, innerView, nullptr, true);
 
   return mInnerView;
--- a/layout/generic/nsSubDocumentFrame.h
+++ b/layout/generic/nsSubDocumentFrame.h
@@ -82,17 +82,17 @@ public:
 
 #ifdef ACCESSIBILITY
   virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
 #endif
 
   nsresult GetDocShell(nsIDocShell **aDocShell);
   nsresult BeginSwapDocShells(nsIFrame* aOther);
   void EndSwapDocShells(nsIFrame* aOther);
-  nsIView* EnsureInnerView();
+  nsView* EnsureInnerView();
   nsIFrame* GetSubdocumentRootFrame();
 
   // nsIReflowCallback
   virtual bool ReflowFinished() MOZ_OVERRIDE;
   virtual void ReflowCallbackCanceled() MOZ_OVERRIDE;
 
   bool ShouldClipSubdocument()
   {
@@ -138,16 +138,16 @@ protected:
 
   /**
    * Return true if pointer event hit-testing should be allowed to target
    * content in the subdocument.
    */
   bool PassPointerEventsToChildren();
 
   nsRefPtr<nsFrameLoader> mFrameLoader;
-  nsIView* mInnerView;
+  nsView* mInnerView;
   bool mIsInline;
   bool mPostedReflowCallback;
   bool mDidCreateDoc;
   bool mCallingShow;
 };
 
 #endif /* NSSUBDOCUMENTFRAME_H_ */
--- a/layout/printing/nsPrintEngine.cpp
+++ b/layout/printing/nsPrintEngine.cpp
@@ -13,17 +13,17 @@
 #include "nsIScriptGlobalObject.h"
 #include "nsPIDOMWindow.h"
 #include "nsIDocShell.h"
 #include "nsIFrame.h"
 #include "nsIURI.h"
 #include "nsITextToSubURI.h"
 #include "nsError.h"
 
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsAsyncDOMEvent.h"
 
 // Print Options
 #include "nsIPrintSettings.h"
 #include "nsIPrintSettingsService.h"
 #include "nsIPrintOptions.h"
 #include "nsIPrintSession.h"
 #include "nsGfxCIID.h"
@@ -86,17 +86,17 @@ static const char kPrintingPromptService
 #include "nsIPresShell.h"
 #include "nsLayoutUtils.h"
 #include "mozilla/Preferences.h"
 
 #include "nsViewsCID.h"
 #include "nsWidgetsCID.h"
 #include "nsIDeviceContextSpec.h"
 #include "nsIViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsRenderingContext.h"
 
 #include "nsIPageSequenceFrame.h"
 #include "nsIURL.h"
 #include "nsIContentViewerEdit.h"
 #include "nsIContentViewerFile.h"
 #include "nsIMarkupDocumentViewer.h"
 #include "nsIInterfaceRequestor.h"
@@ -2074,17 +2074,17 @@ nsPrintEngine::DoSetPixelScale()
   bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
   if (ppIsShrinkToFit) {
     mPrt->mShrinkRatio = mPrtPreview->mShrinkRatio;
     doSetPixelScale = true;
   }
   return doSetPixelScale;
 }
 
-nsIView*
+nsView*
 nsPrintEngine::GetParentViewForRoot()
 {
   if (mIsCreatingPrintPreview) {
     nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
     if (cv) {
       return cv->FindContainerView();
     }
   }
@@ -2096,18 +2096,18 @@ nsPrintEngine::SetRootView(
     nsPrintObject* aPO, 
     bool& doReturn, 
     bool& documentIsTopLevel, 
     nsSize& adjSize
 )
 {
   bool canCreateScrollbars = true;
 
-  nsIView* rootView;
-  nsIView* parentView = nullptr;
+  nsView* rootView;
+  nsView* parentView = nullptr;
 
   doReturn = false;
 
   if (aPO->mParent && aPO->mParent->IsPrintable()) {
     nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nullptr;
     // Without a frame, this document can't be displayed; therefore, there is no
     // point to reflowing it
     if (!frame) {
@@ -2120,17 +2120,17 @@ nsPrintEngine::SetRootView(
     // zoom this would be wrong as we use the same mPrt->mPrintDC for all
     // subdocuments.
     adjSize = frame->GetContentRect().Size();
     documentIsTopLevel = false;
     // presshell exists because parent is printable
 
     // the top nsPrintObject's widget will always have scrollbars
     if (frame && frame->GetType() == nsGkAtoms::subDocumentFrame) {
-      nsIView* view = frame->GetView();
+      nsView* view = frame->GetView();
       NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
       view = view->GetFirstChild();
       NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
       parentView = view;
       canCreateScrollbars = false;
     }
   } else {
     nscoord pageWidth, pageHeight;
@@ -2174,17 +2174,17 @@ nsPrintEngine::ReflowPrintObject(nsPrint
   }
   
   NS_ASSERTION(!aPO->mPresContext, "Recreating prescontext");
 
   // create the PresContext
   nsPresContext::nsPresContextType type =
       mIsCreatingPrintPreview ? nsPresContext::eContext_PrintPreview:
                                 nsPresContext::eContext_Print;
-  nsIView* parentView =
+  nsView* parentView =
     aPO->mParent && aPO->mParent->IsPrintable() ? nullptr : GetParentViewForRoot();
   aPO->mPresContext = parentView ?
       new nsPresContext(aPO->mDocument, type) :
       new nsRootPresContext(aPO->mDocument, type);
   NS_ENSURE_TRUE(aPO->mPresContext, NS_ERROR_OUT_OF_MEMORY);
   aPO->mPresContext->SetPrintSettings(mPrt->mPrintSettings);
 
   // set the presentation context to the value in the print settings
@@ -2282,17 +2282,17 @@ nsPrintEngine::ReflowPrintObject(nsPrint
         fprintf(fd, "URL:   %s\n", urlStr?urlStr:"");
         fprintf(fd, "--------------- Frames ----------------\n");
         nsRefPtr<nsRenderingContext> renderingContext;
         mPrt->mPrintDocDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
         RootFrameList(aPO->mPresContext, fd, 0);
         //DumpFrames(fd, aPO->mPresContext, renderingContext, theRootFrame, 0);
         fprintf(fd, "---------------------------------------\n\n");
         fprintf(fd, "--------------- Views From Root Frame----------------\n");
-        nsIView* v = theRootFrame->GetView();
+        nsView* v = theRootFrame->GetView();
         if (v) {
           v->List(fd);
         } else {
           printf("View is null!\n");
         }
         if (docShell) {
           fprintf(fd, "--------------- All Views ----------------\n");
           DumpViews(docShell, fd);
@@ -3791,17 +3791,17 @@ DumpViews(nsIDocShell* aDocShell, FILE* 
   NS_ASSERTION(out, "Pointer is null!");
 
   if (nullptr != aDocShell) {
     fprintf(out, "docshell=%p \n", aDocShell);
     nsIPresShell* shell = nsPrintEngine::GetPresShellFor(aDocShell);
     if (shell) {
       nsIViewManager* vm = shell->GetViewManager();
       if (vm) {
-        nsIView* root = vm->GetRootView();
+        nsView* root = vm->GetRootView();
         if (root) {
           root->List(out);
         }
       }
     }
     else {
       fputs("null pres shell\n", out);
     }
@@ -3857,17 +3857,17 @@ void DumpLayoutData(char*              a
     fprintf(fd, "--------------- Frames ----------------\n");
     fprintf(fd, "--------------- Frames ----------------\n");
     nsRefPtr<nsRenderingContext> renderingContext;
     aDC->CreateRenderingContext(*getter_AddRefs(renderingContext));
     RootFrameList(aPresContext, fd, 0);
     //DumpFrames(fd, aPresContext, renderingContext, aRootFrame, 0);
     fprintf(fd, "---------------------------------------\n\n");
     fprintf(fd, "--------------- Views From Root Frame----------------\n");
-    nsIView* v = aRootFrame->GetView();
+    nsView* v = aRootFrame->GetView();
     if (v) {
       v->List(fd);
     } else {
       printf("View is null!\n");
     }
     if (aDocShell) {
       fprintf(fd, "--------------- All Views ----------------\n");
       DumpViews(aDocShell, fd);
--- a/layout/printing/nsPrintEngine.h
+++ b/layout/printing/nsPrintEngine.h
@@ -282,17 +282,17 @@ protected:
   bool mDidLoadDataForPrinting;
 
   nsresult AfterNetworkPrint(bool aHandleError);
 
   nsresult SetRootView(nsPrintObject* aPO,
                        bool& aDoReturn,
                        bool& aDocumentIsTopLevel,
                        nsSize& aAdjSize);
-  nsIView* GetParentViewForRoot();
+  nsView* GetParentViewForRoot();
   bool DoSetPixelScale();
   void UpdateZoomRatio(nsPrintObject* aPO, bool aSetPixelScale);
   nsresult ReconstructAndReflow(bool aDoSetPixelScale);
   nsresult UpdateSelectionAndShrinkPrintObject(nsPrintObject* aPO,
                                                bool aDocumentIsTopLevel);
   nsresult InitPrintDocConstruction(bool aHandleError);
   void FirePrintPreviewUpdateEvent();
 private:
--- a/layout/tools/layout-debug/src/nsLayoutDebuggingTools.cpp
+++ b/layout/tools/layout-debug/src/nsLayoutDebuggingTools.cpp
@@ -430,17 +430,17 @@ nsLayoutDebuggingTools::DumpFrames()
 static
 void
 DumpViewsRecur(nsIDocShell* aDocShell, FILE* out)
 {
 #ifdef DEBUG
     fprintf(out, "docshell=%p \n", static_cast<void*>(aDocShell));
     nsCOMPtr<nsIViewManager> vm(view_manager(aDocShell));
     if (vm) {
-        nsIView* root = vm->GetRootView();
+        nsView* root = vm->GetRootView();
         if (root) {
             root->List(out);
         }
     }
     else {
         fputs("null view manager\n", out);
     }
 
@@ -522,17 +522,17 @@ nsLayoutDebuggingTools::DumpReflowStats(
     return NS_OK;
 }
 
 void nsLayoutDebuggingTools::ForceRefresh()
 {
     nsCOMPtr<nsIViewManager> vm(view_manager(mDocShell));
     if (!vm)
         return;
-    nsIView* root = vm->GetRootView();
+    nsView* root = vm->GetRootView();
     if (root) {
         vm->InvalidateView(root);
     }
 }
 
 nsresult
 nsLayoutDebuggingTools::SetBoolPrefAndRefresh(const char * aPrefName,
                                               bool aNewVal)
--- a/layout/tools/layout-debug/src/nsRegressionTester.cpp
+++ b/layout/tools/layout-debug/src/nsRegressionTester.cpp
@@ -21,17 +21,17 @@
 #include "nsIContentViewerFile.h"
 #include "nsIFrame.h"
 #include "nsStyleStruct.h"
 #include "nsIFrameUtil.h"
 #include "nsLayoutCID.h"
 #include "nsNetUtil.h"
 #include "nsIFile.h"
 #include "nsIViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 
 
 
 static NS_DEFINE_CID(kFrameUtilCID, NS_FRAME_UTIL_CID);
 
 
 nsRegressionTester::nsRegressionTester()
 {
--- a/layout/xul/base/src/nsBox.cpp
+++ b/layout/xul/base/src/nsBox.cpp
@@ -566,17 +566,17 @@ nsBox::SyncLayout(nsBoxLayoutState& aSta
       // frames in HTML inside XUL).
       nsLayoutUtils::UnionChildOverflow(this, overflowAreas);
     }
 
     FinishAndStoreOverflow(overflowAreas, GetSize());
     visualOverflow = overflowAreas.VisualOverflow();
   }
 
-  nsIView* view = GetView();
+  nsView* view = GetView();
   if (view) {
     // Make sure the frame's view is properly sized and positioned and has
     // things like opacity correct
     nsContainerFrame::SyncFrameViewAfterReflow(presContext, this, view,
                                                visualOverflow, flags);
   } 
 
   return NS_OK;
--- a/layout/xul/base/src/nsBoxFrame.cpp
+++ b/layout/xul/base/src/nsBoxFrame.cpp
@@ -37,17 +37,17 @@
 #include "nsStyleContext.h"
 #include "nsPresContext.h"
 #include "nsCOMPtr.h"
 #include "nsINameSpaceManager.h"
 #include "nsGkAtoms.h"
 #include "nsIContent.h"
 #include "nsHTMLParts.h"
 #include "nsIViewManager.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIPresShell.h"
 #include "nsCSSRendering.h"
 #include "nsIServiceManager.h"
 #include "nsBoxLayout.h"
 #include "nsSprocketLayout.h"
 #include "nsIScrollableFrame.h"
 #include "nsWidgetsCID.h"
 #include "nsCSSAnonBoxes.h"
--- a/layout/xul/base/src/nsBoxObject.cpp
+++ b/layout/xul/base/src/nsBoxObject.cpp
@@ -8,17 +8,17 @@
 #include "nsIDocument.h"
 #include "nsIPresShell.h"
 #include "nsPresContext.h"
 #include "nsIContent.h"
 #include "nsIFrame.h"
 #include "nsIDocShell.h"
 #include "nsReadableUtils.h"
 #include "nsDOMClassInfoID.h"
-#include "nsIView.h"
+#include "nsView.h"
 #ifdef MOZ_XUL
 #include "nsIDOMXULElement.h"
 #else
 #include "nsIDOMElement.h"
 #endif
 #include "nsLayoutUtils.h"
 #include "nsISupportsPrimitives.h"
 #include "nsSupportsPrimitives.h"
--- a/layout/xul/base/src/nsListBoxBodyFrame.cpp
+++ b/layout/xul/base/src/nsListBoxBodyFrame.cpp
@@ -16,17 +16,17 @@
 #include "nsIDocument.h"
 #include "nsIDOMEventTarget.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNodeList.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsIScrollableFrame.h"
 #include "nsScrollbarFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsStyleContext.h"
 #include "nsFontMetrics.h"
 #include "nsITimer.h"
 #include "nsAutoPtr.h"
 #include "nsStyleSet.h"
 #include "nsPIBoxObject.h"
 #include "nsINodeInfo.h"
--- a/layout/xul/base/src/nsMenuPopupFrame.cpp
+++ b/layout/xul/base/src/nsMenuPopupFrame.cpp
@@ -117,19 +117,19 @@ nsMenuPopupFrame::Init(nsIContent*      
   // look&feel object
   mMenuCanOverlapOSBar =
     LookAndFeel::GetInt(LookAndFeel::eIntID_MenusCanOverlapOSBar) != 0;
 
   rv = CreatePopupView();
   NS_ENSURE_SUCCESS(rv, rv);
 
   // XXX Hack. The popup's view should float above all other views,
-  // so we use the nsIView::SetFloating() to tell the view manager
+  // so we use the nsView::SetFloating() to tell the view manager
   // about that constraint.
-  nsIView* ourView = GetView();
+  nsView* ourView = GetView();
   nsIViewManager* viewManager = ourView->GetViewManager();
   viewManager->SetViewFloating(ourView, true);
 
   mPopupType = ePopupTypePanel;
   nsIDocument* doc = aContent->OwnerDoc();
   int32_t namespaceID;
   nsCOMPtr<nsIAtom> tag = doc->BindingManager()->ResolveTag(aContent, &namespaceID);
   if (namespaceID == kNameSpaceID_XUL) {
@@ -222,26 +222,26 @@ nsMenuPopupFrame::PopupLevel(bool aIsNoA
 
   // Otherwise, the result depends on the platform.
   return sDefaultLevelIsTop ? ePopupLevelTop : ePopupLevelParent;
 }
 
 void
 nsMenuPopupFrame::EnsureWidget()
 {
-  nsIView* ourView = GetView();
+  nsView* ourView = GetView();
   if (!ourView->HasWidget()) {
     NS_ASSERTION(!mGeneratedChildren && !GetFirstPrincipalChild(),
                  "Creating widget for MenuPopupFrame with children");
     CreateWidgetForView(ourView);
   }
 }
 
 nsresult
-nsMenuPopupFrame::CreateWidgetForView(nsIView* aView)
+nsMenuPopupFrame::CreateWidgetForView(nsView* aView)
 {
   // Create a widget for ourselves.
   nsWidgetInitData widgetData;
   widgetData.mWindowType = eWindowType_popup;
   widgetData.mBorderStyle = eBorderStyle_default;
   widgetData.clipSiblings = true;
   widgetData.mPopupHint = mPopupType;
   widgetData.mNoAutoHide = IsNoAutoHide();
@@ -443,17 +443,17 @@ nsMenuPopupFrame::LayoutPopup(nsBoxLayou
       mPrefSize = newsize;
       if (isOpen) {
         SetPopupPosition(nullptr, false);
       }
     }
   }
 
   nsPresContext* pc = PresContext();
-  nsIView* view = GetView();
+  nsView* view = GetView();
 
   if (sizeChanged) {
     // If the size of the popup changed, apply any size constraints.
     nsIWidget* widget = view->GetWidget();
     if (widget) {
       SetSizeConstraints(pc, widget, minSize, maxSize);
     }
   }
@@ -788,17 +788,17 @@ nsMenuPopupFrame::HidePopup(bool aDesele
   mIncrementalString.Truncate();
 
   LockMenuUntilClosed(false);
 
   mIsOpenChanged = false;
   mCurrentMenu = nullptr; // make sure no current menu is set
   mHFlip = mVFlip = false;
 
-  nsIView* view = GetView();
+  nsView* view = GetView();
   nsIViewManager* viewManager = view->GetViewManager();
   viewManager->SetViewVisibility(view, nsViewVisibility_kHide);
 
   FireDOMEvent(NS_LITERAL_STRING("DOMMenuInactive"), mContent);
 
   // XXX, bug 137033, In Windows, if mouse is outside the window when the menupopup closes, no
   // mouse_enter/mouse_exit event will be fired to clear current hover state, we should clear it manually.
   // This code may not the best solution, but we can leave it here until we find the better approach.
@@ -822,35 +822,35 @@ nsMenuPopupFrame::GetLayoutFlags(uint32_
   aFlags = NS_FRAME_NO_SIZE_VIEW | NS_FRAME_NO_MOVE_VIEW | NS_FRAME_NO_VISIBILITY;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GetRootViewForPopup
 //   Retrieves the view for the popup widget that contains the given frame. 
 //   If the given frame is not contained by a popup widget, return the
 //   root view of the root viewmanager.
-nsIView*
+nsView*
 nsMenuPopupFrame::GetRootViewForPopup(nsIFrame* aStartFrame)
 {
-  nsIView* view = aStartFrame->GetClosestView();
+  nsView* view = aStartFrame->GetClosestView();
   NS_ASSERTION(view, "frame must have a closest view!");
   while (view) {
     // Walk up the view hierarchy looking for a view whose widget has a 
     // window type of eWindowType_popup - in other words a popup window
     // widget. If we find one, this is the view we want. 
     nsIWidget* widget = view->GetWidget();
     if (widget) {
       nsWindowType wtype;
       widget->GetWindowType(wtype);
       if (wtype == eWindowType_popup) {
         return view;
       }
     }
 
-    nsIView* temp = view->GetParent();
+    nsView* temp = view->GetParent();
     if (!temp) {
       // Otherwise, we've walked all the way up to the root view and not
       // found a view for a popup window widget. Just return the root view.
       return view;
     }
     view = temp;
   }
 
@@ -1266,17 +1266,17 @@ nsMenuPopupFrame::SetPopupPosition(nsIFr
   // determine the x and y position of the view by subtracting the desired
   // screen position from the screen position of the root frame.
   nsPoint viewPoint = screenPoint - rootScreenRect.TopLeft();
 
   // snap the view's position to device pixels, see bug 622507
   viewPoint.x = presContext->RoundAppUnitsToNearestDevPixels(viewPoint.x);
   viewPoint.y = presContext->RoundAppUnitsToNearestDevPixels(viewPoint.y);
 
-  nsIView* view = GetView();
+  nsView* view = GetView();
   NS_ASSERTION(view, "popup with no view");
 
   // Offset the position by the width and height of the borders and titlebar.
   // Even though GetClientOffset should return (0, 0) when there is no
   // titlebar or borders, we skip these calculations anyway for non-panels
   // to save time since they will never have a titlebar.
   nsIWidget* widget = view->GetWidget();
   if (mPopupType == ePopupTypePanel && widget) {
@@ -1726,17 +1726,17 @@ nsMenuPopupFrame::LockMenuUntilClosed(bo
       parentParent->LockMenuUntilClosed(aLock);
     }
   }
 }
 
 nsIWidget*
 nsMenuPopupFrame::GetWidget()
 {
-  nsIView * view = GetRootViewForPopup(this);
+  nsView * view = GetRootViewForPopup(this);
   if (!view)
     return nullptr;
 
   return view->GetWidget();
 }
 
 void
 nsMenuPopupFrame::AttachedDismissalListener()
@@ -1768,17 +1768,17 @@ nsMenuPopupFrame::AttributeChanged(int32
   nsresult rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute,
                                              aModType);
   
   if (aAttribute == nsGkAtoms::left || aAttribute == nsGkAtoms::top)
     MoveToAttributePosition();
 
   if (aAttribute == nsGkAtoms::label) {
     // set the label for the titlebar
-    nsIView* view = GetView();
+    nsView* view = GetView();
     if (view) {
       nsIWidget* widget = view->GetWidget();
       if (widget) {
         nsAutoString title;
         mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, title);
         if (!title.IsEmpty()) {
           widget->SetTitle(title);
         }
@@ -1918,25 +1918,25 @@ nsMenuPopupFrame::CreatePopupView()
   if (HasView()) {
     return NS_OK;
   }
 
   nsIViewManager* viewManager = PresContext()->GetPresShell()->GetViewManager();
   NS_ASSERTION(nullptr != viewManager, "null view manager");
 
   // Create a view
-  nsIView* parentView = viewManager->GetRootView();
+  nsView* parentView = viewManager->GetRootView();
   nsViewVisibility visibility = nsViewVisibility_kHide;
   int32_t zIndex = INT32_MAX;
   bool    autoZIndex = false;
 
   NS_ASSERTION(parentView, "no parent view");
 
   // Create a view
-  nsIView *view = viewManager->CreateView(GetRect(), parentView, visibility);
+  nsView *view = viewManager->CreateView(GetRect(), parentView, visibility);
   if (view) {
     viewManager->SetViewZIndex(view, autoZIndex, zIndex);
     // XXX put view last in document order until we can do better
     viewManager->InsertChild(parentView, view, nullptr, true);
   }
 
   // Remember our view
   SetView(view);
--- a/layout/xul/base/src/nsMenuPopupFrame.h
+++ b/layout/xul/base/src/nsMenuPopupFrame.h
@@ -86,17 +86,17 @@ enum FlipStyle {
 //  need to find a good place to put them together.
 //  if someone changes one, please also change the other.
 
 #define CONTEXT_MENU_OFFSET_PIXELS 2
 
 nsIFrame* NS_NewMenuPopupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 
 class nsIViewManager;
-class nsIView;
+class nsView;
 class nsMenuPopupFrame;
 
 class nsMenuPopupFrame : public nsBoxFrame, public nsMenuParent
 {
 public:
   NS_DECL_QUERYFRAME_TARGET(nsMenuPopupFrame)
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
@@ -165,28 +165,28 @@ public:
 
   nsPopupLevel PopupLevel() const
   {
     return PopupLevel(IsNoAutoHide()); 
   }
 
   void EnsureWidget();
 
-  nsresult CreateWidgetForView(nsIView* aView);
+  nsresult CreateWidgetForView(nsView* aView);
   uint8_t GetShadowStyle();
 
   NS_IMETHOD SetInitialChildList(ChildListID     aListID,
                                  nsFrameList&    aChildList) MOZ_OVERRIDE;
 
   virtual bool IsLeaf() const;
 
   // layout, position and display the popup as needed
   void LayoutPopup(nsBoxLayoutState& aState, nsIFrame* aParentMenu, bool aSizedToPopup);
 
-  nsIView* GetRootViewForPopup(nsIFrame* aStartFrame);
+  nsView* GetRootViewForPopup(nsIFrame* aStartFrame);
 
   // set the position of the popup either relative to the anchor aAnchorFrame
   // (or the frame for mAnchorContent if aAnchorFrame is null) or at a specific
   // point if a screen position (mScreenXPos and mScreenYPos) are set. The popup
   // will be adjusted so that it is on screen. If aIsMove is true, then the popup
   // is being moved, and should not be flipped.
   nsresult SetPopupPosition(nsIFrame* aAnchorFrame, bool aIsMove);
 
--- a/layout/xul/base/src/nsPopupBoxObject.cpp
+++ b/layout/xul/base/src/nsPopupBoxObject.cpp
@@ -287,17 +287,17 @@ nsPopupBoxObject::GetOuterScreenRect(nsI
   if (!menuPopupFrame)
     return NS_OK;
 
   // Return an empty rectangle if the popup is not open.
   nsPopupState state = menuPopupFrame->PopupState();
   if (state != ePopupOpen && state != ePopupOpenAndVisible)
     return NS_OK;
 
-  nsIView* view = menuPopupFrame->GetView();
+  nsView* view = menuPopupFrame->GetView();
   if (view) {
     nsIWidget* widget = view->GetWidget();
     if (widget) {
       nsIntRect screenRect;
       widget->GetScreenBounds(screenRect);
 
       int32_t pp = menuPopupFrame->PresContext()->AppUnitsPerDevPixel();
       rect->SetLayoutRect(screenRect.ToAppUnits(pp));
--- a/layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
+++ b/layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
@@ -33,17 +33,17 @@
 #include "nsIDOMDocument.h"
 #include "nsIDOMXULElement.h"
 #include "nsIDocument.h"
 #include "mozilla/css/StyleRule.h"
 #include "nsCSSRendering.h"
 #include "nsIXULTemplateBuilder.h"
 #include "nsXPIDLString.h"
 #include "nsContainerFrame.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsIViewManager.h"
 #include "nsWidgetsCID.h"
 #include "nsBoxFrame.h"
 #include "nsBoxObject.h"
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 #include "nsBoxLayoutState.h"
 #include "nsTreeContentView.h"
--- a/tools/trace-malloc/types.dat
+++ b/tools/trace-malloc/types.dat
@@ -3491,17 +3491,17 @@ nsObserverList::AddObserver(nsIObserver 
 PR_Malloc
 PL_HashTableFinalize(PLHashTable *)
 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
 nsHashtable::nsHashtable(unsigned int, int)
 nsViewManager::nsViewManager(void)
 
 <nsViewManager2>
 __builtin_new
-nsViewManager2::AddToDisplayList(int *, nsIView *, nsRect &, nsRect &, unsigned int, int, int)
+nsViewManager2::AddToDisplayList(int *, nsView *, nsRect &, nsRect &, unsigned int, int, int)
 
 # ----------------------------------------------------------------------
 #
 # nsBindingManager
 #
 
 <nsBindingManager>
 PR_Malloc
--- a/view/public/Makefile.in
+++ b/view/public/Makefile.in
@@ -8,16 +8,16 @@ topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
 MODULE		= view
 
 EXPORTS		= \
-		nsIView.h \
+		nsView.h \
 		nsIViewManager.h \
 		nsViewsCID.h \
 		nsIScrollPositionListener.h \
 		$(NULL)
 
 include $(topsrcdir)/config/rules.mk
 
--- a/view/public/nsIViewManager.h
+++ b/view/public/nsIViewManager.h
@@ -2,17 +2,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsIViewManager_h___
 #define nsIViewManager_h___
 
 #include "nscore.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsEvent.h"
 
 class nsIWidget;
 struct nsRect;
 class nsRegion;
 class nsDeviceContext;
 class nsIPresShell;
 
@@ -33,40 +33,40 @@ public:
    */
   NS_IMETHOD  Init(nsDeviceContext* aContext) = 0;
 
   /**
    * Create an ordinary view
    * @param aBounds initial bounds for view
    *        XXX We should eliminate this parameter; you can set the bounds after CreateView
    * @param aParent intended parent for view. this is not actually set in the
-   *        nsIView through this method. it is only used by the initialization
+   *        nsView through this method. it is only used by the initialization
    *        code to walk up the view tree, if necessary, to find resources.
    *        XXX We should eliminate this parameter!
    * @param aVisibilityFlag initial visibility state of view
    *        XXX We should eliminate this parameter; you can set it after CreateView
    * @result The new view
    */
-  NS_IMETHOD_(nsIView*) CreateView(const nsRect& aBounds,
-                                   const nsIView* aParent,
+  NS_IMETHOD_(nsView*) CreateView(const nsRect& aBounds,
+                                   const nsView* aParent,
                                    nsViewVisibility aVisibilityFlag = nsViewVisibility_kShow) = 0;
 
   /**
    * Get the root of the view tree.
    * @result the root view
    */
-  NS_IMETHOD_(nsIView*) GetRootView() = 0;
+  NS_IMETHOD_(nsView*) GetRootView() = 0;
 
   /**
    * Set the root of the view tree. Does not destroy the current root view.
    * aView may have a parent view managed by a different view manager.
    * aView may have a widget (anything but printing) or may not (printing).
    * @param aView view to set as root
    */
-  NS_IMETHOD  SetRootView(nsIView *aView) = 0;
+  NS_IMETHOD  SetRootView(nsView *aView) = 0;
 
   /**
    * Get the dimensions of the root window. The dimensions are in
    * twips
    * @param aWidth out parameter for width of window in twips
    * @param aHeight out parameter for height of window in twips
    */
   NS_IMETHOD  GetWindowDimensions(nscoord *aWidth, nscoord *aHeight) = 0;
@@ -85,108 +85,108 @@ public:
    */
   NS_IMETHOD  FlushDelayedResize(bool aDoReflow) = 0;
 
   /**
    * Called to inform the view manager that the entire area of a view
    * is dirty and needs to be redrawn.
    * @param aView view to paint. should be root view
    */
-  NS_IMETHOD  InvalidateView(nsIView *aView) = 0;
+  NS_IMETHOD  InvalidateView(nsView *aView) = 0;
 
   /**
    * Called to inform the view manager that some portion of a view is dirty and
    * needs to be redrawn. The rect passed in should be in the view's coordinate
    * space. Does not check for paint suppression.
    * @param aView view to paint. should be root view
    * @param rect rect to mark as damaged
    */
-  NS_IMETHOD  InvalidateViewNoSuppression(nsIView *aView, const nsRect &aRect) = 0;
+  NS_IMETHOD  InvalidateViewNoSuppression(nsView *aView, const nsRect &aRect) = 0;
 
   /**
    * Called to inform the view manager that it should invalidate all views.
    */
   NS_IMETHOD  InvalidateAllViews() = 0;
 
   /**
    * Called to dispatch an event to the appropriate view. Often called
    * as a result of receiving a mouse or keyboard event from the widget
    * event system.
    * @param aEvent event to dispatch
    * @param aViewTarget dispatch the event to this view
    * @param aStatus event handling status
    */
   NS_IMETHOD  DispatchEvent(nsGUIEvent *aEvent,
-      nsIView* aViewTarget, nsEventStatus* aStatus) = 0;
+      nsView* aViewTarget, nsEventStatus* aStatus) = 0;
 
   /**
    * Given a parent view, insert another view as its child.
    * aSibling and aAbove control the "document order" for the insertion.
    * If aSibling is null, the view is inserted at the end of the document order
    * if aAfter is true, otherwise it is inserted at the beginning.
    * If aSibling is non-null, then if aAfter is true, the view is inserted
    * after the sibling in document order (appearing above the sibling unless
    * overriden by z-order).
    * If it is false, the view is inserted before the sibling.
    * The view manager generates the appopriate dirty regions.
    * @param aParent parent view
    * @param aChild child view
    * @param aSibling sibling view
    * @param aAfter after or before in the document order
    */
-  NS_IMETHOD  InsertChild(nsIView *aParent, nsIView *aChild, nsIView *aSibling,
+  NS_IMETHOD  InsertChild(nsView *aParent, nsView *aChild, nsView *aSibling,
                           bool aAfter) = 0;
 
   /**
    * Remove a specific child view from its parent. This will NOT remove its placeholder
    * if there is one.
    * The view manager generates the appropriate dirty regions.
    * @param aParent parent view
    * @param aChild child view
    */
-  NS_IMETHOD  RemoveChild(nsIView *aChild) = 0;
+  NS_IMETHOD  RemoveChild(nsView *aChild) = 0;
 
   /**
    * Move a view to the specified position, provided in parent coordinates.
    * The new position is the (0, 0) origin for the view's coordinate system.
    * The view's bounds may extend above or to the left of this point.
    * The view manager generates the appropriate dirty regions.
    * @param aView view to move
    * @param aX x value for new view position
    * @param aY y value for new view position
    */
-  NS_IMETHOD  MoveViewTo(nsIView *aView, nscoord aX, nscoord aY) = 0;
+  NS_IMETHOD  MoveViewTo(nsView *aView, nscoord aX, nscoord aY) = 0;
 
   /**
    * Resize a view. In addition to setting the width and height, you can
    * set the x and y of its bounds relative to its position. Negative x and y
    * will let the view extend above and to the left of the (0,0) point in its
    * coordinate system.
    * The view manager generates the appropriate dirty regions.
    * @param aView view to move
    * @param the new bounds relative to the current position
    * @param RepaintExposedAreaOnly
    *     if true Repaint only the expanded or contracted region,
    *     if false Repaint the union of the old and new rectangles.
    */
-  NS_IMETHOD  ResizeView(nsIView *aView, const nsRect &aRect,
+  NS_IMETHOD  ResizeView(nsView *aView, const nsRect &aRect,
                          bool aRepaintExposedAreaOnly = false) = 0;
 
   /**
    * Set the visibility of a view. Hidden views have the effect of hiding
    * their descendants as well. This does not affect painting, so layout
    * is responsible for ensuring that content in hidden views is not
    * painted nor handling events. It does affect the visibility of widgets;
    * if a view is hidden, descendant views with widgets have their widgets
    * hidden.
    * The view manager generates the appropriate dirty regions.
    * @param aView view to change visibility state of
    * @param visible new visibility state
    */
-  NS_IMETHOD  SetViewVisibility(nsIView *aView, nsViewVisibility aVisible) = 0;
+  NS_IMETHOD  SetViewVisibility(nsView *aView, nsViewVisibility aVisible) = 0;
 
   /**
    * Set the z-index of a view. Positive z-indices mean that a view
    * is above its parent in z-order. Negative z-indices mean that a
    * view is below its parent.
    * The view manager generates the appropriate dirty regions.
    * @param aAutoZIndex indicate that the z-index of a view is "auto". An "auto" z-index
    * means that the view does not define a new stacking context,
@@ -194,26 +194,26 @@ public:
    * relative to the view's siblings.
    * @param aView view to change z depth of
    * @param aZindex explicit z depth
    * @param aTopMost used when this view is z-index:auto to compare against 
    *        other z-index:auto views.
    *        true if the view should be topmost when compared with 
    *        other z-index:auto views.
    */
-  NS_IMETHOD  SetViewZIndex(nsIView *aView, bool aAutoZIndex, int32_t aZindex, bool aTopMost = false) = 0;
+  NS_IMETHOD  SetViewZIndex(nsView *aView, bool aAutoZIndex, int32_t aZindex, bool aTopMost = false) = 0;
 
   /**
    * Set whether the view "floats" above all other views,
    * which tells the compositor not to consider higher views in
    * the view hierarchy that would geometrically intersect with
    * this view. This is a hack, but it fixes some problems with
    * views that need to be drawn in front of all other views.
    */
-  NS_IMETHOD  SetViewFloating(nsIView *aView, bool aFloatingView) = 0;
+  NS_IMETHOD  SetViewFloating(nsView *aView, bool aFloatingView) = 0;
 
   /**
    * Set the presshell associated with this manager
    * @param aPresShell - new presshell
    */
   virtual void SetPresShell(nsIPresShell *aPresShell) = 0;
 
   /**
@@ -287,17 +287,17 @@ public:
    * @param aTime Last user event time in microseconds
    */
   NS_IMETHOD GetLastUserEventTime(uint32_t& aTime)=0;
 
   /**
    * Find the nearest display root view for the view aView. This is the view for
    * the nearest enclosing popup or the root view for the root document.
    */
-  static nsIView* GetDisplayRootFor(nsIView* aView);
+  static nsView* GetDisplayRootFor(nsView* aView);
 
   /**
    * Flush the accumulated dirty region to the widget and update widget
    * geometry.
    */
   virtual void ProcessPendingUpdates()=0;
 
   /**
rename from view/public/nsIView.h
rename to view/public/nsView.h
--- a/view/public/nsIView.h
+++ b/view/public/nsView.h
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef nsIView_h___
-#define nsIView_h___
+#ifndef nsView_h__
+#define nsView_h__
 
 #include "nsISupports.h"
 #include "nsCoord.h"
 #include "nsRect.h"
 #include "nsPoint.h"
 #include "nsNativeWidget.h"
 #include "nsIWidget.h"
 #include "nsWidgetInitData.h"
@@ -57,17 +57,17 @@ enum nsViewVisibility {
  *
  * The lifetime of the view hierarchy is bounded by the lifetime of the
  * view manager that owns the views.
  *
  * Most of the methods here are read-only. To set the corresponding properties
  * of a view, go through nsIViewManager.
  */
 
-class nsIView MOZ_FINAL : public nsIWidgetListener
+class nsView MOZ_FINAL : public nsIWidgetListener
 {
 public:
   friend class nsViewManager;
 
   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
 
   /**
    * Get the view manager which "owns" the view.
@@ -79,17 +79,17 @@ public:
   { return reinterpret_cast<nsIViewManager*>(mViewManager); }
   nsViewManager* GetViewManagerInternal() const { return mViewManager; }
 
   /**
    * Find the view for the given widget, if there is one.
    * @return the view the widget belongs to, or null if the widget doesn't
    * belong to any view.
    */
-  static nsIView* GetViewFor(nsIWidget* aWidget);
+  static nsView* GetViewFor(nsIWidget* aWidget);
 
   /**
    * Destroy the view.
    *
    * The view destroys its child views, and destroys and releases its
    * widget (if it has one).
    *
    * Also informs the view manager that the view is destroyed by calling
@@ -143,17 +143,17 @@ public:
    * If aOther is null, this will return the offset of |this| from the
    * root of the viewmanager tree.
    * 
    * This function is fastest when aOther is an ancestor of |this|.
    *
    * NOTE: this actually returns the offset from aOther to |this|, but
    * that offset is added to transform _coordinates_ from |this| to aOther.
    */
-  nsPoint GetOffsetTo(const nsIView* aOther) const;
+  nsPoint GetOffsetTo(const nsView* aOther) const;
 
   /**
    * Get the offset between the origin of |this| and the origin of aWidget.
    * Adding the return value to a point in the coordinate system of |this|
    * will transform the point to the coordinate system of aWidget.
    *
    * The offset is expressed in appunits of |this|.
    */
@@ -181,29 +181,29 @@ public:
    * @result true if the view floats, false otherwise.
    */
   bool GetFloating() const { return (mVFlags & NS_VIEW_FLAG_FLOATING) != 0; }
 
   /**
    * Called to query the parent of the view.
    * @result view's parent
    */
-  nsIView* GetParent() const { return mParent; }
+  nsView* GetParent() const { return mParent; }
 
   /**
    * The view's first child is the child which is earliest in document order.
    * @result first child
    */
-  nsIView* GetFirstChild() const { return mFirstChild; }
+  nsView* GetFirstChild() const { return mFirstChild; }
 
   /**
    * Called to query the next sibling of the view.
    * @result view's next sibling
    */
-  nsIView* GetNextSibling() const { return mNextSibling; }
+  nsView* GetNextSibling() const { return mNextSibling; }
 
   /**
    * Set the view's frame.
    */
   void SetFrame(nsIFrame* aRootFrame) { mFrame = aRootFrame; }
 
   /**
    * Retrieve the view's frame.
@@ -354,18 +354,18 @@ public:
    * which means that the z-indicies of the view's children are
    * relative to the view's siblings.
    * @param zindex new z depth
    */
   void SetZIndex(bool aAuto, int32_t aZIndex, bool aTopMost);
   bool GetZIndexIsAuto() const { return (mVFlags & NS_VIEW_FLAG_AUTO_ZINDEX) != 0; }
   int32_t GetZIndex() const { return mZIndex; }
 
-  void SetParent(nsIView *aParent) { mParent = aParent; }
-  void SetNextSibling(nsIView *aSibling)
+  void SetParent(nsView *aParent) { mParent = aParent; }
+  void SetNextSibling(nsView *aSibling)
   {
     NS_ASSERTION(aSibling != this, "Can't be our own sibling!");
     mNextSibling = aSibling;
   }
 
   nsRegion* GetDirtyRegion() {
     if (!mDirtyRegion) {
       NS_ASSERTION(!mParent || GetFloating(),
@@ -376,33 +376,33 @@ public:
     return mDirtyRegion;
   }
 
   uint32_t GetViewFlags() const { return mVFlags; }
   void SetViewFlags(uint32_t aFlags) { mVFlags = aFlags; }
 
   // nsIWidgetListener
   virtual nsIPresShell* GetPresShell() MOZ_OVERRIDE;
-  virtual nsIView* GetView() MOZ_OVERRIDE { return this; }
+  virtual nsView* GetView() MOZ_OVERRIDE { return this; }
   virtual bool WindowMoved(nsIWidget* aWidget, int32_t x, int32_t y) MOZ_OVERRIDE;
   virtual bool WindowResized(nsIWidget* aWidget, int32_t aWidth, int32_t aHeight) MOZ_OVERRIDE;
   virtual bool RequestWindowClose(nsIWidget* aWidget) MOZ_OVERRIDE;
   virtual void WillPaintWindow(nsIWidget* aWidget, bool aWillSendDidPaint) MOZ_OVERRIDE;
   virtual bool PaintWindow(nsIWidget* aWidget, nsIntRegion aRegion, uint32_t aFlags) MOZ_OVERRIDE;
   virtual void DidPaintWindow() MOZ_OVERRIDE;
   virtual void RequestRepaint() MOZ_OVERRIDE;
   virtual nsEventStatus HandleEvent(nsGUIEvent* aEvent, bool aUseAttachedEvents) MOZ_OVERRIDE;
 
-  virtual ~nsIView();
+  virtual ~nsView();
 
-  nsPoint GetOffsetTo(const nsIView* aOther, const int32_t aAPD) const;
+  nsPoint GetOffsetTo(const nsView* aOther, const int32_t aAPD) const;
   nsIWidget* GetNearestWidget(nsPoint* aOffset, const int32_t aAPD) const;
 
 private:
-  nsIView(nsViewManager* aViewManager = nullptr,
+  nsView(nsViewManager* aViewManager = nullptr,
           nsViewVisibility aVisibility = nsViewVisibility_kShow);
 
   bool ForcedRepaint() { return mForcedRepaint; }
 
   // Do the actual work of ResetWidgetBounds, unconditionally.  Don't
   // call this method if we have no widget.
   void DoResetWidgetBounds(bool aMoveOnly, bool aInvalidateChangedSize);
   void InitializeWindow(bool aEnableDragDrop, bool aResetVisibility);
@@ -441,38 +441,38 @@ private:
 
   // Same as GetBounds but converts to parent appunits if they are different.
   nsRect GetBoundsInParentUnits() const;
 
   bool HasNonEmptyDirtyRegion() {
     return mDirtyRegion && !mDirtyRegion->IsEmpty();
   }
 
-  void InsertChild(nsIView *aChild, nsIView *aSibling);
-  void RemoveChild(nsIView *aChild);
+  void InsertChild(nsView *aChild, nsView *aSibling);
+  void RemoveChild(nsView *aChild);
 
   void SetTopMost(bool aTopMost) { aTopMost ? mVFlags |= NS_VIEW_FLAG_TOPMOST : mVFlags &= ~NS_VIEW_FLAG_TOPMOST; }
   bool IsTopMost() { return((mVFlags & NS_VIEW_FLAG_TOPMOST) != 0); }
 
   void ResetWidgetBounds(bool aRecurse, bool aForceSync);
   void AssertNoWindow();
 
   void NotifyEffectiveVisibilityChanged(bool aEffectivelyVisible);
 
   // Update the cached RootViewManager for all view manager descendents,
   // If the hierarchy is being removed, aViewManagerParent points to the view
   // manager for the hierarchy's old parent, and will have its mouse grab
   // released if it points to any view in this view hierarchy.
   void InvalidateHierarchy(nsViewManager *aViewManagerParent);
 
   nsViewManager     *mViewManager;
-  nsIView           *mParent;
+  nsView           *mParent;
   nsIWidget         *mWindow;
-  nsIView           *mNextSibling;
-  nsIView           *mFirstChild;
+  nsView           *mNextSibling;
+  nsView           *mFirstChild;
   nsIFrame          *mFrame;
   nsRegion          *mDirtyRegion;
   int32_t           mZIndex;
   nsViewVisibility  mVis;
   // position relative our parent view origin but in our appunits
   nscoord           mPosX, mPosY;
   // relative to parent, but in our appunits
   nsRect            mDimBounds;
--- a/view/src/nsView.cpp
+++ b/view/src/nsView.cpp
@@ -1,14 +1,14 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "nsIView.h"
+#include "nsView.h"
 
 #include "mozilla/Attributes.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/Likely.h"
 #include "nsIWidget.h"
 #include "nsWidgetsCID.h"
 #include "nsViewManager.h"
 #include "nsIFrame.h"
@@ -16,59 +16,59 @@
 #include "nsIComponentManager.h"
 #include "nsGfxCIID.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsXULPopupManager.h"
 #include "nsIWidgetListener.h"
 
 using namespace mozilla;
 
-nsIView::nsIView(nsViewManager* aViewManager, nsViewVisibility aVisibility)
+nsView::nsView(nsViewManager* aViewManager, nsViewVisibility aVisibility)
 {
-  MOZ_COUNT_CTOR(nsIView);
+  MOZ_COUNT_CTOR(nsView);
 
   mVis = aVisibility;
   // Views should be transparent by default. Not being transparent is
   // a promise that the view will paint all its pixels opaquely. Views
   // should make this promise explicitly by calling
   // SetViewContentTransparency.
   mVFlags = 0;
   mViewManager = aViewManager;
   mDirtyRegion = nullptr;
   mWidgetIsTopLevel = false;
   mInAlternatePaint = false;
 }
 
-void nsIView::DropMouseGrabbing()
+void nsView::DropMouseGrabbing()
 {
   nsIPresShell* presShell = mViewManager->GetPresShell();
   if (presShell)
     presShell->ClearMouseCaptureOnView(this);
 }
 
-nsIView::~nsIView()
+nsView::~nsView()
 {
-  MOZ_COUNT_DTOR(nsIView);
+  MOZ_COUNT_DTOR(nsView);
 
   while (GetFirstChild())
   {
-    nsIView* child = GetFirstChild();
+    nsView* child = GetFirstChild();
     if (child->GetViewManager() == mViewManager) {
       child->Destroy();
     } else {
       // just unhook it. Someone else will want to destroy this.
       RemoveChild(child);
     }
   }
 
   if (mViewManager)
   {
     DropMouseGrabbing();
   
-    nsIView *rootView = mViewManager->GetRootViewImpl();
+    nsView *rootView = mViewManager->GetRootViewImpl();
     
     if (rootView)
     {
       // Root views can have parents!
       if (mParent)
       {
         mViewManager->RemoveChild(this);
       }
@@ -92,17 +92,17 @@ nsIView::~nsIView()
   }
 
   // Destroy and release the widget
   DestroyWidget();
 
   delete mDirtyRegion;
 }
 
-void nsIView::DestroyWidget()
+void nsView::DestroyWidget()
 {
   if (mWindow)
   {
     // If we are not attached to a base window, we're going to tear down our
     // widget here. However, if we're attached to somebody elses widget, we
     // want to leave the widget alone: don't reset the client data or call
     // Destroy. Just clear our event view ptr and free our reference to it. 
     if (mWidgetIsTopLevel) {
@@ -112,86 +112,86 @@ void nsIView::DestroyWidget()
       mWindow->SetWidgetListener(nullptr);
       mWindow->Destroy();
     }
 
     NS_RELEASE(mWindow);
   }
 }
 
-nsIView* nsIView::GetViewFor(nsIWidget* aWidget)
+nsView* nsView::GetViewFor(nsIWidget* aWidget)
 {
   NS_PRECONDITION(nullptr != aWidget, "null widget ptr");
 
   nsIWidgetListener* listener = aWidget->GetWidgetListener();
   if (listener) {
-    nsIView* view = listener->GetView();
+    nsView* view = listener->GetView();
     if (view)
       return view;
   }
 
   listener = aWidget->GetAttachedWidgetListener();
   return listener ? listener->GetView() : nullptr;
 }
 
-void nsIView::Destroy()
+void nsView::Destroy()
 {
   delete this;
 }
 
-void nsIView::SetPosition(nscoord aX, nscoord aY)
+void nsView::SetPosition(nscoord aX, nscoord aY)
 {
   mDimBounds.x += aX - mPosX;
   mDimBounds.y += aY - mPosY;
   mPosX = aX;
   mPosY = aY;
 
   NS_ASSERTION(GetParent() || (aX == 0 && aY == 0),
                "Don't try to move the root widget to something non-zero");
 
   ResetWidgetBounds(true, false);
 }
 
-void nsIView::ResetWidgetBounds(bool aRecurse, bool aForceSync)
+void nsView::ResetWidgetBounds(bool aRecurse, bool aForceSync)
 {
   if (mWindow) {
     if (!aForceSync) {
       // Don't change widget geometry synchronously, since that can
       // cause synchronous painting.
       mViewManager->PostPendingUpdate();
     } else {
       DoResetWidgetBounds(false, true);
     }
     return;
   }
 
   if (aRecurse) {
     // reposition any widgets under this view
-    for (nsIView* v = GetFirstChild(); v; v = v->GetNextSibling()) {
+    for (nsView* v = GetFirstChild(); v; v = v->GetNextSibling()) {
       v->ResetWidgetBounds(true, aForceSync);
     }
   }
 }
 
-bool nsIView::IsEffectivelyVisible()
+bool nsView::IsEffectivelyVisible()
 {
-  for (nsIView* v = this; v; v = v->mParent) {
+  for (nsView* v = this; v; v = v->mParent) {
     if (v->GetVisibility() == nsViewVisibility_kHide)
       return false;
   }
   return true;
 }
 
-nsIntRect nsIView::CalcWidgetBounds(nsWindowType aType)
+nsIntRect nsView::CalcWidgetBounds(nsWindowType aType)
 {
   int32_t p2a = mViewManager->AppUnitsPerDevPixel();
 
   nsRect viewBounds(mDimBounds);
 
-  nsIView* parent = GetParent();
+  nsView* parent = GetParent();
   if (parent) {
     nsPoint offset;
     nsIWidget* parentWidget = parent->GetNearestWidget(&offset, p2a);
     // make viewBounds be relative to the parent widget, in appunits
     viewBounds += offset;
 
     if (parentWidget && aType == eWindowType_popup &&
         IsEffectivelyVisible()) {
@@ -216,17 +216,17 @@ nsIntRect nsIView::CalcWidgetBounds(nsWi
   // (mPosX,mPosY) - mDimBounds.TopLeft() + viewBounds.TopLeft().
   // Our widget, relative to the parent widget, is roundedOffset.
   mViewToWidgetOffset = nsPoint(mPosX, mPosY)
     - mDimBounds.TopLeft() + viewBounds.TopLeft() - roundedOffset;
 
   return newBounds;
 }
 
-void nsIView::DoResetWidgetBounds(bool aMoveOnly,
+void nsView::DoResetWidgetBounds(bool aMoveOnly,
                                  bool aInvalidateChangedSize) {
   // The geometry of a root view's widget is controlled externally,
   // NOT by sizing or positioning the view
   if (mViewManager->GetRootViewImpl() == this) {
     return;
   }
   
   nsIntRect curBounds;
@@ -278,17 +278,17 @@ void nsIView::DoResetWidgetBounds(bool a
     if (changedSize && !aMoveOnly) {
       mWindow->ResizeClient(newBounds.width * invScale,
                             newBounds.height * invScale,
                             aInvalidateChangedSize);
     } // else do nothing!
   }
 }
 
-void nsIView::SetDimensions(const nsRect& aRect, bool aPaint, bool aResizeWidget)
+void nsView::SetDimensions(const nsRect& aRect, bool aPaint, bool aResizeWidget)
 {
   nsRect dims = aRect;
   dims.MoveBy(mPosX, mPosY);
 
   // Don't use nsRect's operator== here, since it returns true when
   // both rects are empty even if they have different widths and we
   // have cases where that sort of thing matters to us.
   if (mDimBounds.TopLeft() == dims.TopLeft() &&
@@ -298,17 +298,17 @@ void nsIView::SetDimensions(const nsRect
 
   mDimBounds = dims;
 
   if (aResizeWidget) {
     ResetWidgetBounds(false, false);
   }
 }
 
-void nsIView::NotifyEffectiveVisibilityChanged(bool aEffectivelyVisible)
+void nsView::NotifyEffectiveVisibilityChanged(bool aEffectivelyVisible)
 {
   if (!aEffectivelyVisible)
   {
     DropMouseGrabbing();
   }
 
   if (nullptr != mWindow)
   {
@@ -316,50 +316,50 @@ void nsIView::NotifyEffectiveVisibilityC
     {
       DoResetWidgetBounds(false, true);
       mWindow->Show(true);
     }
     else
       mWindow->Show(false);
   }
 
-  for (nsIView* child = mFirstChild; child; child = child->mNextSibling) {
+  for (nsView* child = mFirstChild; child; child = child->mNextSibling) {
     if (child->mVis == nsViewVisibility_kHide) {
       // It was effectively hidden and still is
       continue;
     }
     // Our child is visible if we are
     child->NotifyEffectiveVisibilityChanged(aEffectivelyVisible);
   }
 }
 
-void nsIView::SetVisibility(nsViewVisibility aVisibility)
+void nsView::SetVisibility(nsViewVisibility aVisibility)
 {
   mVis = aVisibility;
   NotifyEffectiveVisibilityChanged(IsEffectivelyVisible());
 }
 
-void nsIView::SetFloating(bool aFloatingView)
+void nsView::SetFloating(bool aFloatingView)
 {
 	if (aFloatingView)
 		mVFlags |= NS_VIEW_FLAG_FLOATING;
 	else
 		mVFlags &= ~NS_VIEW_FLAG_FLOATING;
 }
 
-void nsIView::InvalidateHierarchy(nsViewManager *aViewManagerParent)
+void nsView::InvalidateHierarchy(nsViewManager *aViewManagerParent)
 {
   if (mViewManager->GetRootViewImpl() == this)
     mViewManager->InvalidateHierarchy();
 
-  for (nsIView *child = mFirstChild; child; child = child->GetNextSibling())
+  for (nsView *child = mFirstChild; child; child = child->GetNextSibling())
     child->InvalidateHierarchy(aViewManagerParent);
 }
 
-void nsIView::InsertChild(nsIView *aChild, nsIView *aSibling)
+void nsView::InsertChild(nsView *aChild, nsView *aSibling)
 {
   NS_PRECONDITION(nullptr != aChild, "null ptr");
 
   if (nullptr != aChild)
   {
     if (nullptr != aSibling)
     {
 #ifdef DEBUG
@@ -382,24 +382,24 @@ void nsIView::InsertChild(nsIView *aChil
     nsViewManager *vm = aChild->GetViewManagerInternal();
     if (vm->GetRootViewImpl() == aChild)
     {
       aChild->InvalidateHierarchy(nullptr); // don't care about releasing grabs
     }
   }
 }
 
-void nsIView::RemoveChild(nsIView *child)
+void nsView::RemoveChild(nsView *child)
 {
   NS_PRECONDITION(nullptr != child, "null ptr");
 
   if (nullptr != child)
   {
-    nsIView* prevKid = nullptr;
-    nsIView* kid = mFirstChild;
+    nsView* prevKid = nullptr;
+    nsView* kid = mFirstChild;
     DebugOnly<bool> found = false;
     while (nullptr != kid) {
       if (kid == child) {
         if (nullptr != prevKid) {
           prevKid->SetNextSibling(kid->GetNextSibling());
         } else {
           mFirstChild = kid->GetNextSibling();
         }
@@ -423,35 +423,35 @@ void nsIView::RemoveChild(nsIView *child
   }
 }
 
 // Native widgets ultimately just can't deal with the awesome power of
 // CSS2 z-index. However, we set the z-index on the widget anyway
 // because in many simple common cases the widgets do end up in the
 // right order. We set each widget's z-index to the z-index of the
 // nearest ancestor that has non-auto z-index.
-static void UpdateNativeWidgetZIndexes(nsIView* aView, int32_t aZIndex)
+static void UpdateNativeWidgetZIndexes(nsView* aView, int32_t aZIndex)
 {
   if (aView->HasWidget()) {
     nsIWidget* widget = aView->GetWidget();
     int32_t curZ;
     widget->GetZIndex(&curZ);
     if (curZ != aZIndex) {
       widget->SetZIndex(aZIndex);
     }
   } else {
-    for (nsIView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
+    for (nsView* v = aView->GetFirstChild(); v; v = v->GetNextSibling()) {
       if (v->GetZIndexIsAuto()) {
         UpdateNativeWidgetZIndexes(v, aZIndex);
       }
     }
   }
 }
 
-static int32_t FindNonAutoZIndex(nsIView* aView)
+static int32_t FindNonAutoZIndex(nsView* aView)
 {
   while (aView) {
     if (!aView->GetZIndexIsAuto()) {
       return aView->GetZIndex();
     }
     aView = aView->GetParent();
   }
   return 0;
@@ -461,17 +461,17 @@ struct DefaultWidgetInitData : public ns
   DefaultWidgetInitData() : nsWidgetInitData()
   {
     mWindowType = eWindowType_child;
     clipChildren = true;
     clipSiblings = true;
   }
 };
 
-nsresult nsIView::CreateWidget(nsWidgetInitData *aWidgetInitData,
+nsresult nsView::CreateWidget(nsWidgetInitData *aWidgetInitData,
                                bool aEnableDragDrop,
                                bool aResetVisibility)
 {
   AssertNoWindow();
   NS_ABORT_IF_FALSE(!aWidgetInitData ||
                     aWidgetInitData->mWindowType != eWindowType_popup,
                     "Use CreateWidgetForPopup");
 
@@ -485,34 +485,34 @@ nsresult nsIView::CreateWidget(nsWidgetI
   nsIntRect trect = CalcWidgetBounds(aWidgetInitData->mWindowType);
 
   nsRefPtr<nsDeviceContext> dx;
   mViewManager->GetDeviceContext(*getter_AddRefs(dx));
 
   nsIWidget* parentWidget =
     GetParent() ? GetParent()->GetNearestWidget(nullptr) : nullptr;
   if (!parentWidget) {
-    NS_ERROR("nsIView::CreateWidget without suitable parent widget??");
+    NS_ERROR("nsView::CreateWidget without suitable parent widget??");
     return NS_ERROR_FAILURE;
   }
 
   // XXX: using aForceUseIWidgetParent=true to preserve previous
   // semantics.  It's not clear that it's actually needed.
   mWindow = parentWidget->CreateChild(trect, dx, aWidgetInitData,
                                       true).get();
   if (!mWindow) {
     return NS_ERROR_FAILURE;
   }
  
   InitializeWindow(aEnableDragDrop, aResetVisibility);
 
   return NS_OK;
 }
 
-nsresult nsIView::CreateWidgetForParent(nsIWidget* aParentWidget,
+nsresult nsView::CreateWidgetForParent(nsIWidget* aParentWidget,
                                         nsWidgetInitData *aWidgetInitData,
                                         bool aEnableDragDrop,
                                         bool aResetVisibility)
 {
   AssertNoWindow();
   NS_ABORT_IF_FALSE(!aWidgetInitData ||
                     aWidgetInitData->mWindowType != eWindowType_popup,
                     "Use CreateWidgetForPopup");
@@ -532,17 +532,17 @@ nsresult nsIView::CreateWidgetForParent(
     return NS_ERROR_FAILURE;
   }
 
   InitializeWindow(aEnableDragDrop, aResetVisibility);
 
   return NS_OK;
 }
 
-nsresult nsIView::CreateWidgetForPopup(nsWidgetInitData *aWidgetInitData,
+nsresult nsView::CreateWidgetForPopup(nsWidgetInitData *aWidgetInitData,
                                        nsIWidget* aParentWidget,
                                        bool aEnableDragDrop,
                                        bool aResetVisibility)
 {
   AssertNoWindow();
   NS_ABORT_IF_FALSE(aWidgetInitData, "Widget init data required");
   NS_ABORT_IF_FALSE(aWidgetInitData->mWindowType == eWindowType_popup,
                     "Use one of the other CreateWidget methods");
@@ -579,17 +579,17 @@ nsresult nsIView::CreateWidgetForPopup(n
   }
 
   InitializeWindow(aEnableDragDrop, aResetVisibility);
 
   return NS_OK;
 }
 
 void
-nsIView::InitializeWindow(bool aEnableDragDrop, bool aResetVisibility)
+nsView::InitializeWindow(bool aEnableDragDrop, bool aResetVisibility)
 {
   NS_ABORT_IF_FALSE(mWindow, "Must have a window to initialize");
 
   mWindow->SetWidgetListener(this);
 
   if (aEnableDragDrop) {
     mWindow->EnableDragDrop(true);
   }
@@ -600,24 +600,24 @@ nsIView::InitializeWindow(bool aEnableDr
   //make sure visibility state is accurate
 
   if (aResetVisibility) {
     SetVisibility(GetVisibility());
   }
 }
 
 // Attach to a top level widget and start receiving mirrored events.
-nsresult nsIView::AttachToTopLevelWidget(nsIWidget* aWidget)
+nsresult nsView::AttachToTopLevelWidget(nsIWidget* aWidget)
 {
   NS_PRECONDITION(nullptr != aWidget, "null widget ptr");
   /// XXXjimm This is a temporary workaround to an issue w/document
   // viewer (bug 513162).
   nsIWidgetListener* listener = aWidget->GetAttachedWidgetListener();
   if (listener) {
-    nsIView *oldView = listener->GetView();
+    nsView *oldView = listener->GetView();
     if (oldView) {
       oldView->DetachFromTopLevelWidget();
     }
   }
 
   nsRefPtr<nsDeviceContext> dx;
   mViewManager->GetDeviceContext(*getter_AddRefs(dx));
 
@@ -638,73 +638,73 @@ nsresult nsIView::AttachToTopLevelWidget
   nsWindowType type;
   mWindow->GetWindowType(type);
   CalcWidgetBounds(type);
 
   return NS_OK;
 }
 
 // Detach this view from an attached widget. 
-nsresult nsIView::DetachFromTopLevelWidget()
+nsresult nsView::DetachFromTopLevelWidget()
 {
   NS_PRECONDITION(mWidgetIsTopLevel, "Not attached currently!");
   NS_PRECONDITION(mWindow, "null mWindow for DetachFromTopLevelWidget!");
 
   mWindow->SetAttachedWidgetListener(nullptr);
   NS_RELEASE(mWindow);
 
   mWidgetIsTopLevel = false;
   
   return NS_OK;
 }
 
-void nsIView::SetZIndex(bool aAuto, int32_t aZIndex, bool aTopMost)
+void nsView::SetZIndex(bool aAuto, int32_t aZIndex, bool aTopMost)
 {
   bool oldIsAuto = GetZIndexIsAuto();
   mVFlags = (mVFlags & ~NS_VIEW_FLAG_AUTO_ZINDEX) | (aAuto ? NS_VIEW_FLAG_AUTO_ZINDEX : 0);
   mZIndex = aZIndex;
   SetTopMost(aTopMost);
   
   if (HasWidget() || !oldIsAuto || !aAuto) {
     UpdateNativeWidgetZIndexes(this, FindNonAutoZIndex(this));
   }
 }
 
-void nsIView::AssertNoWindow()
+void nsView::AssertNoWindow()
 {
   // XXX: it would be nice to make this a strong assert
   if (MOZ_UNLIKELY(mWindow)) {
     NS_ERROR("We already have a window for this view? BAD");
     mWindow->SetWidgetListener(nullptr);
     mWindow->Destroy();
     NS_RELEASE(mWindow);
   }
 }
 
 //
 // internal window creation functions
 //
-void nsIView::AttachWidgetEventHandler(nsIWidget* aWidget)
+void nsView::AttachWidgetEventHandler(nsIWidget* aWidget)
 {
 #ifdef DEBUG
   NS_ASSERTION(!aWidget->GetWidgetListener(), "Already have a widget listener");
 #endif
 
   aWidget->SetWidgetListener(this);
 }
 
-void nsIView::DetachWidgetEventHandler(nsIWidget* aWidget)
+void nsView::DetachWidgetEventHandler(nsIWidget* aWidget)
 {
   NS_ASSERTION(!aWidget->GetWidgetListener() ||
                aWidget->GetWidgetListener()->GetView() == this, "Wrong view");
   aWidget->SetWidgetListener(nullptr);
 }
 
 #ifdef DEBUG
-void nsIView::List(FILE* out, int32_t aIndent) const
+void nsView::List(FILE* out, int32_t aIndent) const
 {
   int32_t i;
   for (i = aIndent; --i >= 0; ) fputs("  ", out);
   fprintf(out, "%p ", (void*)this);
   if (nullptr != mWindow) {
     nscoord p2a = mViewManager->AppUnitsPerDevPixel();
     nsIntRect rect;
     mWindow->GetClientBounds(rect);
@@ -720,43 +720,43 @@ void nsIView::List(FILE* out, int32_t aI
             nonclientBounds.x, nonclientBounds.y,
             windowBounds.width, windowBounds.height);
   }
   nsRect brect = GetBounds();
   fprintf(out, "{%d,%d,%d,%d}",
           brect.x, brect.y, brect.width, brect.height);
   fprintf(out, " z=%d vis=%d frame=%p <\n",
           mZIndex, mVis, static_cast<void*>(mFrame));
-  for (nsIView* kid = mFirstChild; kid; kid = kid->GetNextSibling()) {
+  for (nsView* kid = mFirstChild; kid; kid = kid->GetNextSibling()) {
     NS_ASSERTION(kid->GetParent() == this, "incorrect parent");
     kid->List(out, aIndent + 1);
   }
   for (i = aIndent; --i >= 0; ) fputs("  ", out);
   fputs(">\n", out);
 }
 #endif // DEBUG
 
-nsPoint nsIView::GetOffsetTo(const nsIView* aOther) const
+nsPoint nsView::GetOffsetTo(const nsView* aOther) const
 {
   return GetOffsetTo(aOther, GetViewManagerInternal()->AppUnitsPerDevPixel());
 }
 
-nsPoint nsIView::GetOffsetTo(const nsIView* aOther, const int32_t aAPD) const
+nsPoint nsView::GetOffsetTo(const nsView* aOther, const int32_t aAPD) const
 {
   NS_ABORT_IF_FALSE(GetParent() || !aOther || aOther->GetParent() ||
                     this == aOther, "caller of (outer) GetOffsetTo must not "
                     "pass unrelated views");
   // We accumulate the final result in offset
   nsPoint offset(0, 0);
   // The offset currently accumulated at the current APD
   nsPoint docOffset(0, 0);
-  const nsIView* v = this;
+  const nsView* v = this;
   nsViewManager* currVM = v->GetViewManagerInternal();
   int32_t currAPD = currVM->AppUnitsPerDevPixel();
-  const nsIView* root = nullptr;
+  const nsView* root = nullptr;
   for ( ; v != aOther && v; root = v, v = v->GetParent()) {
     nsViewManager* newVM = v->GetViewManagerInternal();
     if (newVM != currVM) {
       int32_t newAPD = newVM->AppUnitsPerDevPixel();
       if (newAPD != currAPD) {
         offset += docOffset.ConvertAppUnits(currAPD, aAPD);
         docOffset.x = docOffset.y = 0;
         currAPD = newAPD;
@@ -773,21 +773,21 @@ nsPoint nsIView::GetOffsetTo(const nsIVi
     // root-VM-relative position of aOther and subtract it.
     nsPoint negOffset = aOther->GetOffsetTo(root, aAPD);
     offset -= negOffset;
   }
 
   return offset;
 }
 
-nsPoint nsIView::GetOffsetToWidget(nsIWidget* aWidget) const
+nsPoint nsView::GetOffsetToWidget(nsIWidget* aWidget) const
 {
   nsPoint pt;
   // Get the view for widget
-  nsIView* widgetView = GetViewFor(aWidget);
+  nsView* widgetView = GetViewFor(aWidget);
   if (!widgetView) {
     return pt;
   }
 
   // Get the offset to the widget view in the widget view's APD
   // We get the offset in the widget view's APD first and then convert to our
   // APD afterwards so that we can include the widget view's ViewToWidgetOffset
   // in the sum in its native APD, and then convert the whole thing to our APD
@@ -800,31 +800,31 @@ nsPoint nsIView::GetOffsetToWidget(nsIWi
 
   // Convert to our appunits.
   int32_t widgetAPD = widgetView->GetViewManagerInternal()->AppUnitsPerDevPixel();
   int32_t ourAPD = GetViewManagerInternal()->AppUnitsPerDevPixel();
   pt = pt.ConvertAppUnits(widgetAPD, ourAPD);
   return pt;
 }
 
-nsIWidget* nsIView::GetNearestWidget(nsPoint* aOffset) const
+nsIWidget* nsView::GetNearestWidget(nsPoint* aOffset) const
 {
   return GetNearestWidget(aOffset, GetViewManagerInternal()->AppUnitsPerDevPixel());
 }
 
-nsIWidget* nsIView::GetNearestWidget(nsPoint* aOffset, const int32_t aAPD) const
+nsIWidget* nsView::GetNearestWidget(nsPoint* aOffset, const int32_t aAPD) const
 {
   // aOffset is based on the view's position, which ignores any chrome on
   // attached parent widgets.
 
   // We accumulate the final result in pt
   nsPoint pt(0, 0);
   // The offset currently accumulated at the current APD
   nsPoint docPt(0,0);
-  const nsIView* v = this;
+  const nsView* v = this;
   nsViewManager* currVM = v->GetViewManagerInternal();
   int32_t currAPD = currVM->AppUnitsPerDevPixel();
   for ( ; v && !v->HasWidget(); v = v->GetParent()) {
     nsViewManager* newVM = v->GetViewManagerInternal();
     if (newVM != currVM) {
       int32_t newAPD = newVM->AppUnitsPerDevPixel();
       if (newAPD != currAPD) {
         pt += docPt.ConvertAppUnits(currAPD, aAPD);
@@ -848,39 +848,39 @@ nsIWidget* nsIView::GetNearestWidget(nsP
   if (aOffset) {
     docPt += v->ViewToWidgetOffset();
     pt += docPt.ConvertAppUnits(currAPD, aAPD);
     *aOffset = pt;
   }
   return v->GetWidget();
 }
 
-bool nsIView::IsRoot() const
+bool nsView::IsRoot() const
 {
-  NS_ASSERTION(mViewManager != nullptr," View manager is null in nsIView::IsRoot()");
+  NS_ASSERTION(mViewManager != nullptr," View manager is null in nsView::IsRoot()");
   return mViewManager->GetRootViewImpl() == this;
 }
 
 nsRect
-nsIView::GetBoundsInParentUnits() const
+nsView::GetBoundsInParentUnits() const
 {
-  nsIView* parent = GetParent();
+  nsView* parent = GetParent();
   nsViewManager* VM = GetViewManagerInternal();
   if (this != VM->GetRootViewImpl() || !parent) {
     return mDimBounds;
   }
   int32_t ourAPD = VM->AppUnitsPerDevPixel();
   int32_t parentAPD = parent->GetViewManagerInternal()->AppUnitsPerDevPixel();
   return mDimBounds.ConvertAppUnitsRoundOut(ourAPD, parentAPD);
 }
 
 nsPoint
-nsIView::ConvertFromParentCoords(nsPoint aPt) const
+nsView::ConvertFromParentCoords(nsPoint aPt) const
 {
-  const nsIView* parent = GetParent();
+  const nsView* parent = GetParent();
   if (parent) {
     aPt = aPt.ConvertAppUnits(parent->GetViewManagerInternal()->AppUnitsPerDevPixel(),
                               GetViewManagerInternal()->AppUnitsPerDevPixel());
   }
   aPt -= GetPosition();
   return aPt;
 }
 
@@ -888,35 +888,35 @@ static bool
 IsPopupWidget(nsIWidget* aWidget)
 {
   nsWindowType type;
   aWidget->GetWindowType(type);
   return (type == eWindowType_popup);
 }
 
 nsIPresShell*
-nsIView::GetPresShell()
+nsView::GetPresShell()
 {
   return GetViewManager()->GetPresShell();
 }
 
 bool
-nsIView::WindowMoved(nsIWidget* aWidget, int32_t x, int32_t y)
+nsView::WindowMoved(nsIWidget* aWidget, int32_t x, int32_t y)
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm && IsPopupWidget(aWidget)) {
     pm->PopupMoved(mFrame, nsIntPoint(x, y));
     return true;
   }
 
   return false;
 }
 
 bool
-nsIView::WindowResized(nsIWidget* aWidget, int32_t aWidth, int32_t aHeight)
+nsView::WindowResized(nsIWidget* aWidget, int32_t aWidth, int32_t aHeight)
 {
   // The root view may not be set if this is the resize associated with
   // window creation
   SetForcedRepaint(true);
   if (this == mViewManager->GetRootView()) {
     nsRefPtr<nsDeviceContext> devContext;
     mViewManager->GetDeviceContext(*getter_AddRefs(devContext));
     int32_t p2a = devContext->AppUnitsPerDevPixel();
@@ -931,77 +931,77 @@ nsIView::WindowResized(nsIWidget* aWidge
       return true;
     }
   }
 
   return false;
 }
 
 bool
-nsIView::RequestWindowClose(nsIWidget* aWidget)
+nsView::RequestWindowClose(nsIWidget* aWidget)
 {
   if (mFrame && IsPopupWidget(aWidget) &&
       mFrame->GetType() == nsGkAtoms::menuPopupFrame) {
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm) {
       pm->HidePopup(mFrame->GetContent(), false, true, false);
       return true;
     }
   }
 
   return false;
 }
 
 void
-nsIView::WillPaintWindow(nsIWidget* aWidget, bool aWillSendDidPaint)
+nsView::WillPaintWindow(nsIWidget* aWidget, bool aWillSendDidPaint)
 {
   nsCOMPtr<nsViewManager> vm = mViewManager;
   vm->WillPaintWindow(aWidget, aWillSendDidPaint);
 }
 
 bool
-nsIView::PaintWindow(nsIWidget* aWidget, nsIntRegion aRegion, uint32_t aFlags)
+nsView::PaintWindow(nsIWidget* aWidget, nsIntRegion aRegion, uint32_t aFlags)
 {
-  NS_ASSERTION(this == nsIView::GetViewFor(aWidget), "wrong view for widget?");
+  NS_ASSERTION(this == nsView::GetViewFor(aWidget), "wrong view for widget?");
 
   mInAlternatePaint = aFlags & PAINT_IS_ALTERNATE;
   nsCOMPtr<nsViewManager> vm = mViewManager;
   bool result = vm->PaintWindow(aWidget, aRegion, aFlags);
   // PaintWindow can destroy this via WillPaintWindow notification, so we have
   // to re-get the view from the widget.
-  nsIView* view = nsIView::GetViewFor(aWidget);
+  nsView* view = nsView::GetViewFor(aWidget);
   if (view) {
     view->mInAlternatePaint = false;
   }
   return result;
 }
 
 void
-nsIView::DidPaintWindow()
+nsView::DidPaintWindow()
 {
   nsCOMPtr<nsViewManager> vm = mViewManager;
   vm->DidPaintWindow();
 }
 
 void
-nsIView::RequestRepaint()
+nsView::RequestRepaint()
 {
   nsIPresShell* presShell = mViewManager->GetPresShell();
   if (presShell) {
     presShell->ScheduleViewManagerFlush();
   }
 }
 
 nsEventStatus
-nsIView::HandleEvent(nsGUIEvent* aEvent, bool aUseAttachedEvents)
+nsView::HandleEvent(nsGUIEvent* aEvent, bool aUseAttachedEvents)
 {
   NS_PRECONDITION(nullptr != aEvent->widget, "null widget ptr");
 
   nsEventStatus result = nsEventStatus_eIgnore;
-  nsIView* view;
+  nsView* view;
   if (aUseAttachedEvents) {
     nsIWidgetListener* listener = aEvent->widget->GetAttachedWidgetListener();
     view = listener ? listener->GetView() : nullptr;
   }
   else {
     view = GetViewFor(aEvent->widget);
   }
 
--- a/view/src/nsViewManager.cpp
+++ b/view/src/nsViewManager.cpp
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #define PL_ARENA_CONST_ALIGN_MASK (sizeof(void*)-1)
 #include "plarena.h"
 
 #include "nsAutoPtr.h"
 #include "nsViewManager.h"
 #include "nsGfxCIID.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "nsISupportsArray.h"
 #include "nsCOMPtr.h"
 #include "nsGUIEvent.h"
 #include "nsRegion.h"
 #include "nsHashtable.h"
 #include "nsCOMArray.h"
 #include "nsIPluginWidget.h"
 #include "nsXULPopupManager.h"
@@ -136,48 +136,48 @@ NS_IMETHODIMP nsViewManager::Init(nsDevi
   if (nullptr != mContext) {
     return NS_ERROR_ALREADY_INITIALIZED;
   }
   mContext = aContext;
 
   return NS_OK;
 }
 
-NS_IMETHODIMP_(nsIView *)
+NS_IMETHODIMP_(nsView *)
 nsViewManager::CreateView(const nsRect& aBounds,
-                          const nsIView* aParent,
+                          const nsView* aParent,
                           nsViewVisibility aVisibilityFlag)
 {
-  nsIView *v = new nsIView(this, aVisibilityFlag);
+  nsView *v = new nsView(this, aVisibilityFlag);
   if (v) {
-    v->SetParent(const_cast<nsIView*>(aParent));
+    v->SetParent(const_cast<nsView*>(aParent));
     v->SetPosition(aBounds.x, aBounds.y);
     nsRect dim(0, 0, aBounds.width, aBounds.height);
     v->SetDimensions(dim, false);
   }
   return v;
 }
 
-NS_IMETHODIMP_(nsIView*)
+NS_IMETHODIMP_(nsView*)
 nsViewManager::GetRootView()
 {
   return mRootView;
 }
 
-NS_IMETHODIMP nsViewManager::SetRootView(nsIView *aView)
+NS_IMETHODIMP nsViewManager::SetRootView(nsView *aView)
 {
   NS_PRECONDITION(!aView || aView->GetViewManager() == this,
                   "Unexpected viewmanager on root view");
   
   // Do NOT destroy the current root view. It's the caller's responsibility
   // to destroy it
   mRootView = aView;
 
   if (mRootView) {
-    nsIView* parent = mRootView->GetParent();
+    nsView* parent = mRootView->GetParent();
     if (parent) {
       // Calling InsertChild on |parent| will InvalidateHierarchy() on us, so
       // no need to set mRootViewManager ourselves here.
       parent->InsertChild(mRootView, nullptr);
     } else {
       InvalidateHierarchy();
     }
 
@@ -262,32 +262,32 @@ NS_IMETHODIMP nsViewManager::FlushDelaye
     }
   }
   return NS_OK;
 }
 
 // Convert aIn from being relative to and in appunits of aFromView, to being
 // relative to and in appunits of aToView.
 static nsRegion ConvertRegionBetweenViews(const nsRegion& aIn,
-                                          nsIView* aFromView,
-                                          nsIView* aToView)
+                                          nsView* aFromView,
+                                          nsView* aToView)
 {
   nsRegion out = aIn;
   out.MoveBy(aFromView->GetOffsetTo(aToView));
   out = out.ConvertAppUnitsRoundOut(
     aFromView->GetViewManagerInternal()->AppUnitsPerDevPixel(),
     aToView->GetViewManagerInternal()->AppUnitsPerDevPixel());
   return out;
 }
 
-nsIView* nsIViewManager::GetDisplayRootFor(nsIView* aView)
+nsView* nsIViewManager::GetDisplayRootFor(nsView* aView)
 {
-  nsIView *displayRoot = aView;
+  nsView *displayRoot = aView;
   for (;;) {
-    nsIView *displayParent = displayRoot->GetParent();
+    nsView *displayParent = displayRoot->GetParent();
     if (!displayParent)
       return displayRoot;
 
     if (displayRoot->GetFloating() && !displayParent->GetFloating())
       return displayRoot;
 
     // If we have a combobox dropdown popup within a panel popup, both the view
     // for the dropdown popup and its parent will be floating, so we need to
@@ -308,17 +308,17 @@ nsIView* nsIViewManager::GetDisplayRootF
   }
 }
 
 /**
    aRegion is given in device coordinates!!
    aContext may be null, in which case layers should be used for
    rendering.
 */
-void nsViewManager::Refresh(nsIView *aView, const nsIntRegion& aRegion,
+void nsViewManager::Refresh(nsView *aView, const nsIntRegion& aRegion,
                             bool aWillSendDidPaint)
 {
   NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
 
   // damageRegion is the damaged area, in twips, relative to the view origin
   nsRegion damageRegion = aRegion.ToAppUnits(AppUnitsPerDevPixel());
   // move region from widget coordinates into view coordinates
   damageRegion.MoveBy(-aView->ViewToWidgetOffset());
@@ -370,32 +370,32 @@ void nsViewManager::Refresh(nsIView *aVi
   }
 
   if (RootViewManager()->mRecursiveRefreshPending) {
     RootViewManager()->mRecursiveRefreshPending = false;
     InvalidateAllViews();
   }
 }
 
-void nsViewManager::ProcessPendingUpdatesForView(nsIView* aView,
+void nsViewManager::ProcessPendingUpdatesForView(nsView* aView,
                                                  bool aFlushDirtyRegion)
 {
   NS_ASSERTION(IsRootVM(), "Updates will be missed");
 
   // Protect against a null-view.
   if (!aView) {
     return;
   }
 
   if (aView->HasWidget()) {
     aView->ResetWidgetBounds(false, true);
   }
 
   // process pending updates in child view.
-  for (nsIView* childView = aView->GetFirstChild(); childView;
+  for (nsView* childView = aView->GetFirstChild(); childView;
        childView = childView->GetNextSibling()) {
     ProcessPendingUpdatesForView(childView, aFlushDirtyRegion);
   }
 
   // Push out updates after we've processed the children; ensures that
   // damage is applied based on the final widget geometry
   if (aFlushDirtyRegion) {
     if (IsRefreshDriverPaintingEnabled()) {
@@ -414,17 +414,17 @@ void nsViewManager::ProcessPendingUpdate
             vm->InvalidateView(vm->mRootView);
           }
         }
 
         NS_ASSERTION(aView->HasWidget(), "Must have a widget!");
 
         SetPainting(true);
 #ifdef DEBUG_INVALIDATIONS
-        printf("---- PAINT START ----PresShell(%p), nsIView(%p), nsIWidget(%p)\n", mPresShell, aView, widget);
+        printf("---- PAINT START ----PresShell(%p), nsView(%p), nsIWidget(%p)\n", mPresShell, aView, widget);
 #endif
         nsAutoScriptBlocker scriptBlocker;
         NS_ASSERTION(aView->HasWidget(), "Must have a widget!");
         mPresShell->Paint(aView, nsRegion(),
                           nsIPresShell::PAINT_LAYERS |
                           nsIPresShell::PAINT_WILL_SEND_DID_PAINT);
 #ifdef DEBUG_INVALIDATIONS
         printf("---- PAINT END ----\n");
@@ -432,42 +432,42 @@ void nsViewManager::ProcessPendingUpdate
         aView->SetForcedRepaint(false);
         SetPainting(false);
       }
     }
     FlushDirtyRegionToWidget(aView);
   }
 }
 
-void nsViewManager::FlushDirtyRegionToWidget(nsIView* aView)
+void nsViewManager::FlushDirtyRegionToWidget(nsView* aView)
 {
   if (!aView->HasNonEmptyDirtyRegion())
     return;
 
   nsRegion* dirtyRegion = aView->GetDirtyRegion();
-  nsIView* nearestViewWithWidget = aView;
+  nsView* nearestViewWithWidget = aView;
   while (!nearestViewWithWidget->HasWidget() &&
          nearestViewWithWidget->GetParent()) {
     nearestViewWithWidget = nearestViewWithWidget->GetParent();
   }
   nsRegion r =
     ConvertRegionBetweenViews(*dirtyRegion, aView, nearestViewWithWidget);
   nsViewManager* widgetVM = nearestViewWithWidget->GetViewManagerInternal();
   widgetVM->InvalidateWidgetArea(nearestViewWithWidget, r);
   dirtyRegion->SetEmpty();
 }
 
-NS_IMETHODIMP nsViewManager::InvalidateView(nsIView *aView)
+NS_IMETHODIMP nsViewManager::InvalidateView(nsView *aView)
 {
   // Mark the entire view as damaged
   return InvalidateView(aView, aView->GetDimensions());
 }
 
 static void
-AddDirtyRegion(nsIView *aView, const nsRegion &aDamagedRegion)
+AddDirtyRegion(nsView *aView, const nsRegion &aDamagedRegion)
 {
   nsRegion* dirtyRegion = aView->GetDirtyRegion();
   if (!dirtyRegion)
     return;
 
   dirtyRegion->Or(*dirtyRegion, aDamagedRegion);
   dirtyRegion->SimplifyOutward(8);
 }
@@ -482,17 +482,17 @@ nsViewManager::PostPendingUpdate()
   }
 }
 
 /**
  * @param aDamagedRegion this region, relative to aWidgetView, is invalidated in
  * every widget child of aWidgetView, plus aWidgetView's own widget
  */
 void
-nsViewManager::InvalidateWidgetArea(nsIView *aWidgetView,
+nsViewManager::InvalidateWidgetArea(nsView *aWidgetView,
                                     const nsRegion &aDamagedRegion)
 {
   NS_ASSERTION(aWidgetView->GetViewManager() == this,
                "InvalidateWidgetArea called on view we don't own");
   nsIWidget* widget = aWidgetView->GetWidget();
 
 #if 0
   nsRect dbgBounds = aDamagedRegion.GetBounds();
@@ -516,17 +516,17 @@ nsViewManager::InvalidateWidgetArea(nsIV
   // Update all child widgets with the damage. In the process,
   // accumulate the union of all the child widget areas, or at least
   // some subset of that.
   nsRegion children;
   if (widget->GetTransparencyMode() != eTransparencyTransparent) {
     for (nsIWidget* childWidget = widget->GetFirstChild();
          childWidget;
          childWidget = childWidget->GetNextSibling()) {
-      nsIView* view = nsIView::GetViewFor(childWidget);
+      nsView* view = nsView::GetViewFor(childWidget);
       NS_ASSERTION(view != aWidgetView, "will recur infinitely");
       nsWindowType type;
       childWidget->GetWindowType(type);
       if (view && childWidget->IsVisible() && type != eWindowType_popup) {
         NS_ASSERTION(type == eWindowType_plugin,
                      "Only plugin or popup widgets can be children!");
 
         // We do not need to invalidate in plugin widgets, but we should
@@ -566,47 +566,47 @@ nsViewManager::InvalidateWidgetArea(nsIV
 static bool
 ShouldIgnoreInvalidation(nsViewManager* aVM)
 {
   while (aVM) {
     nsIPresShell* shell = aVM->GetPresShell();
     if (!shell || shell->ShouldIgnoreInvalidation()) {
       return true;
     }
-    nsIView* view = aVM->GetRootViewImpl()->GetParent();
+    nsView* view = aVM->GetRootViewImpl()->GetParent();
     aVM = view ? view->GetViewManagerInternal() : nullptr;
   }
   return false;
 }
 
-nsresult nsViewManager::InvalidateView(nsIView *aView, const nsRect &aRect)
+nsresult nsViewManager::InvalidateView(nsView *aView, const nsRect &aRect)
 {
   // If painting is suppressed in the presshell or an ancestor drop all
   // invalidates, it will invalidate everything when it unsuppresses.
   if (ShouldIgnoreInvalidation(this)) {
     return NS_OK;
   }
 
   return InvalidateViewNoSuppression(aView, aRect);
 }
 
-NS_IMETHODIMP nsViewManager::InvalidateViewNoSuppression(nsIView *aView,
+NS_IMETHODIMP nsViewManager::InvalidateViewNoSuppression(nsView *aView,
                                                          const nsRect &aRect)
 {
   NS_PRECONDITION(nullptr != aView, "null view");
 
   NS_ASSERTION(aView->GetViewManager() == this,
                "InvalidateViewNoSuppression called on view we don't own");
 
   nsRect damagedRect(aRect);
   if (damagedRect.IsEmpty()) {
     return NS_OK;
   }
 
-  nsIView* displayRoot = GetDisplayRootFor(aView);
+  nsView* displayRoot = GetDisplayRootFor(aView);
   nsViewManager* displayRootVM = displayRoot->GetViewManagerInternal();
   // Propagate the update to the displayRoot, since iframes, for example,
   // can overlap each other and be translucent.  So we have to possibly
   // invalidate our rect in each of the widgets we have lying about.
   damagedRect.MoveBy(aView->GetOffsetTo(displayRoot));
   int32_t rootAPD = displayRootVM->AppUnitsPerDevPixel();
   int32_t APD = AppUnitsPerDevPixel();
   damagedRect = damagedRect.ConvertAppUnitsRoundOut(APD, rootAPD);
@@ -623,23 +623,23 @@ NS_IMETHODIMP nsViewManager::InvalidateA
   if (RootViewManager() != this) {
     return RootViewManager()->InvalidateAllViews();
   }
   
   InvalidateViews(mRootView);
   return NS_OK;
 }
 
-void nsViewManager::InvalidateViews(nsIView *aView)
+void nsViewManager::InvalidateViews(nsView *aView)
 {
   // Invalidate this view.
   InvalidateView(aView);
 
   // Invalidate all children as well.
-  nsIView* childView = aView->GetFirstChild();
+  nsView* childView = aView->GetFirstChild();
   while (nullptr != childView)  {
     childView->GetViewManagerInternal()->InvalidateViews(childView);
     childView = childView->GetNextSibling();
   }
 }
 
 void nsViewManager::WillPaintWindow(nsIWidget* aWidget, bool aWillSendDidPaint)
 {
@@ -662,22 +662,22 @@ void nsViewManager::WillPaintWindow(nsIW
     nsRefPtr<nsViewManager> rootVM = RootViewManager();
     rootVM->CallWillPaintOnObservers(aWillSendDidPaint);
 
     // Flush view widget geometry updates and invalidations.
     rootVM->ProcessPendingUpdates();
   }
 
   if (aWidget && IsRefreshDriverPaintingEnabled()) {
-    nsIView* view = nsIView::GetViewFor(aWidget);
+    nsView* view = nsView::GetViewFor(aWidget);
     if (view && view->ForcedRepaint()) {
       ProcessPendingUpdates();
       // Re-get the view pointer here since the ProcessPendingUpdates might have
       // destroyed it during CallWillPaintOnObservers.
-      view = nsIView::GetViewFor(aWidget);
+      view = nsView::GetViewFor(aWidget);
       if (view) {
         view->SetForcedRepaint(false);
       }
     }
   }
 
   nsCOMPtr<nsIPresShell> shell = mPresShell;
   if (shell) {
@@ -695,33 +695,33 @@ bool nsViewManager::PaintWindow(nsIWidge
                "shouldn't be receiving paint events while painting is disallowed!");
 
   if (!(aFlags & nsIWidgetListener::SENT_WILL_PAINT) && !IsRefreshDriverPaintingEnabled()) {
     WillPaintWindow(aWidget, (aFlags & nsIWidgetListener::WILL_SEND_DID_PAINT));
   }
 
   // Get the view pointer here since NS_WILL_PAINT might have
   // destroyed it during CallWillPaintOnObservers (bug 378273).
-  nsIView* view = nsIView::GetViewFor(aWidget);
+  nsView* view = nsView::GetViewFor(aWidget);
   if (view && !aRegion.IsEmpty()) {
     Refresh(view, aRegion, (aFlags & nsIWidgetListener::WILL_SEND_DID_PAINT));
   }
 
   return true;
 }
 
 void nsViewManager::DidPaintWindow()
 {
   nsCOMPtr<nsIPresShell> shell = mPresShell;
   if (shell) {
     shell->DidPaintWindow();
   }
 }
 
-nsresult nsViewManager::DispatchEvent(nsGUIEvent *aEvent, nsIView* aView, nsEventStatus* aStatus)
+nsresult nsViewManager::DispatchEvent(nsGUIEvent *aEvent, nsView* aView, nsEventStatus* aStatus)
 {
   SAMPLE_LABEL("event", "nsViewManager::DispatchEvent");
 
   if ((NS_IS_MOUSE_EVENT(aEvent) &&
        // Ignore mouse events that we synthesize.
        static_cast<nsMouseEvent*>(aEvent)->reason == nsMouseEvent::eReal &&
        // Ignore mouse exit and enter (we'll get moves if the user
        // is really moving the mouse) since we get them when we
@@ -730,17 +730,17 @@ nsresult nsViewManager::DispatchEvent(ns
        aEvent->message != NS_MOUSE_ENTER) ||
       NS_IS_KEY_EVENT(aEvent) ||
       NS_IS_IME_EVENT(aEvent) ||
       aEvent->message == NS_PLUGIN_INPUT_EVENT) {
     gLastUserEventTime = PR_IntervalToMicroseconds(PR_IntervalNow());
   }
 
   // Find the view whose coordinates system we're in.
-  nsIView* view = aView;
+  nsView* view = aView;
   bool dispatchUsingCoordinates = NS_IsEventUsingCoordinates(aEvent);
   if (dispatchUsingCoordinates) {
     // Will dispatch using coordinates. Pretty bogus but it's consistent
     // with what presshell does.
     view = GetDisplayRootFor(view);
   }
 
   // If the view has no frame, look for a view that does.
@@ -773,17 +773,17 @@ nsresult nsViewManager::DispatchEvent(ns
 
   *aStatus = nsEventStatus_eIgnore;
 
   return NS_OK;
 }
 
 // Recursively reparent widgets if necessary 
 
-void nsViewManager::ReparentChildWidgets(nsIView* aView, nsIWidget *aNewWidget)
+void nsViewManager::ReparentChildWidgets(nsView* aView, nsIWidget *aNewWidget)
 {
   NS_PRECONDITION(aNewWidget, "");
 
   if (aView->HasWidget()) {
     // Check to see if the parent widget is the
     // same as the new parent. If not then reparent
     // the widget, otherwise there is nothing more
     // to do for the view and its descendants
@@ -803,24 +803,24 @@ void nsViewManager::ReparentChildWidgets
       widget->ReparentNativeWidget(aNewWidget);
     }
     return;
   }
 
   // Need to check each of the views children to see
   // if they have a widget and reparent it.
 
-  for (nsIView *kid = aView->GetFirstChild(); kid; kid = kid->GetNextSibling()) {
+  for (nsView *kid = aView->GetFirstChild(); kid; kid = kid->GetNextSibling()) {
     ReparentChildWidgets(kid, aNewWidget);
   }
 }
 
 // Reparent a view and its descendant views widgets if necessary
 
-void nsViewManager::ReparentWidgets(nsIView* aView, nsIView *aParent)
+void nsViewManager::ReparentWidgets(nsView* aView, nsView *aParent)
 {
   NS_PRECONDITION(aParent, "Must have a parent");
   NS_PRECONDITION(aView, "Must have a view");
   
   // Quickly determine whether the view has pre-existing children or a
   // widget. In most cases the view will not have any pre-existing 
   // children when this is called.  Only in the case
   // where a view has been reparented by removing it from
@@ -832,17 +832,17 @@ void nsViewManager::ReparentWidgets(nsIV
     if (parentWidget) {
       ReparentChildWidgets(aView, parentWidget);
       return;
     }
     NS_WARNING("Can not find a widget for the parent view");
   }
 }
 
-NS_IMETHODIMP nsViewManager::InsertChild(nsIView *aParent, nsIView *aChild, nsIView *aSibling,
+NS_IMETHODIMP nsViewManager::InsertChild(nsView *aParent, nsView *aChild, nsView *aSibling,
                                          bool aAfter)
 {
   NS_PRECONDITION(nullptr != aParent, "null ptr");
   NS_PRECONDITION(nullptr != aChild, "null ptr");
   NS_ASSERTION(aSibling == nullptr || aSibling->GetParent() == aParent,
                "tried to insert view with invalid sibling");
   NS_ASSERTION(!IsViewInserted(aChild), "tried to insert an already-inserted view");
 
@@ -854,29 +854,29 @@ NS_IMETHODIMP nsViewManager::InsertChild
       if (nullptr == aSibling) {
         if (aAfter) {
           // insert at end of document order, i.e., before first view
           // this is the common case, by far
           aParent->InsertChild(aChild, nullptr);
           ReparentWidgets(aChild, aParent);
         } else {
           // insert at beginning of document order, i.e., after last view
-          nsIView *kid = aParent->GetFirstChild();
-          nsIView *prev = nullptr;
+          nsView *kid = aParent->GetFirstChild();
+          nsView *prev = nullptr;
           while (kid) {
             prev = kid;
             kid = kid->GetNextSibling();
           }
           // prev is last view or null if there are no children
           aParent->InsertChild(aChild, prev);
           ReparentWidgets(aChild, aParent);
         }
       } else {
-        nsIView *kid = aParent->GetFirstChild();
-        nsIView *prev = nullptr;
+        nsView *kid = aParent->GetFirstChild();
+        nsView *prev = nullptr;
         while (kid && aSibling != kid) {
           //get the next sibling view
           prev = kid;
           kid = kid->GetNextSibling();
         }
         NS_ASSERTION(kid != nullptr,
                      "couldn't find sibling in child list");
         if (aAfter) {
@@ -897,105 +897,105 @@ NS_IMETHODIMP nsViewManager::InsertChild
       //and mark this area as dirty if the view is visible...
 
       if (nsViewVisibility_kHide != aChild->GetVisibility())
         aChild->GetViewManagerInternal()->InvalidateView(aChild);
     }
   return NS_OK;
 }
 
-NS_IMETHODIMP nsViewManager::InsertChild(nsIView *aParent, nsIView *aChild, int32_t aZIndex)
+NS_IMETHODIMP nsViewManager::InsertChild(nsView *aParent, nsView *aChild, int32_t aZIndex)
 {
   // no-one really calls this with anything other than aZIndex == 0 on a fresh view
   // XXX this method should simply be eliminated and its callers redirected to the real method
   SetViewZIndex(aChild, false, aZIndex, false);
   return InsertChild(aParent, aChild, nullptr, true);
 }
 
-NS_IMETHODIMP nsViewManager::RemoveChild(nsIView *aChild)
+NS_IMETHODIMP nsViewManager::RemoveChild(nsView *aChild)
 {
   NS_ENSURE_ARG_POINTER(aChild);
 
-  nsIView* parent = aChild->GetParent();
+  nsView* parent = aChild->GetParent();
 
   if (nullptr != parent) {
     NS_ASSERTION(aChild->GetViewManager() == this ||
                  parent->GetViewManager() == this, "wrong view manager");
     aChild->GetViewManagerInternal()->InvalidateView(aChild);
     parent->RemoveChild(aChild);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsViewManager::MoveViewTo(nsIView *aView, nscoord aX, nscoord aY)
+NS_IMETHODIMP nsViewManager::MoveViewTo(nsView *aView, nscoord aX, nscoord aY)
 {
   NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
   nsPoint oldPt = aView->GetPosition();
   nsRect oldBounds = aView->GetBoundsInParentUnits();
   aView->SetPosition(aX, aY);
 
   // only do damage control if the view is visible
 
   if ((aX != oldPt.x) || (aY != oldPt.y)) {
     if (aView->GetVisibility() != nsViewVisibility_kHide) {
-      nsIView* parentView = aView->GetParent();
+      nsView* parentView = aView->GetParent();
       if (parentView) {
         nsViewManager* parentVM = parentView->GetViewManagerInternal();
         parentVM->InvalidateView(parentView, oldBounds);
         parentVM->InvalidateView(parentView, aView->GetBoundsInParentUnits());
       }
     }
   }
   return NS_OK;
 }
 
-void nsViewManager::InvalidateHorizontalBandDifference(nsIView *aView, const nsRect& aRect, const nsRect& aCutOut,
+void nsViewManager::InvalidateHorizontalBandDifference(nsView *aView, const nsRect& aRect, const nsRect& aCutOut,
   nscoord aY1, nscoord aY2, bool aInCutOut) {
   nscoord height = aY2 - aY1;
   if (aRect.x < aCutOut.x) {
     nsRect r(aRect.x, aY1, aCutOut.x - aRect.x, height);
     InvalidateView(aView, r);
   }
   if (!aInCutOut && aCutOut.x < aCutOut.XMost()) {
     nsRect r(aCutOut.x, aY1, aCutOut.width, height);
     InvalidateView(aView, r);
   }
   if (aCutOut.XMost() < aRect.XMost()) {
     nsRect r(aCutOut.XMost(), aY1, aRect.XMost() - aCutOut.XMost(), height);
     InvalidateView(aView, r);
   }
 }
 
-void nsViewManager::InvalidateRectDifference(nsIView *aView, const nsRect& aRect, const nsRect& aCutOut) {
+void nsViewManager::InvalidateRectDifference(nsView *aView, const nsRect& aRect, const nsRect& aCutOut) {
   NS_ASSERTION(aView->GetViewManager() == this,
                "InvalidateRectDifference called on view we don't own");
   if (aRect.y < aCutOut.y) {
     InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aRect.y, aCutOut.y, false);
   }
   if (aCutOut.y < aCutOut.YMost()) {
     InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aCutOut.y, aCutOut.YMost(), true);
   }
   if (aCutOut.YMost() < aRect.YMost()) {
     InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aCutOut.YMost(), aRect.YMost(), false);
   }
 }
 
-NS_IMETHODIMP nsViewManager::ResizeView(nsIView *aView, const nsRect &aRect, bool aRepaintExposedAreaOnly)
+NS_IMETHODIMP nsViewManager::ResizeView(nsView *aView, const nsRect &aRect, bool aRepaintExposedAreaOnly)
 {
   NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
 
   nsRect oldDimensions = aView->GetDimensions();
   if (!oldDimensions.IsEqualEdges(aRect)) {
     // resize the view.
     // Prevent Invalidation of hidden views 
     if (aView->GetVisibility() == nsViewVisibility_kHide) {
       aView->SetDimensions(aRect, false);
     } else {
-      nsIView* parentView = aView->GetParent();
+      nsView* parentView = aView->GetParent();
       if (!parentView) {
         parentView = aView;
       }
       nsRect oldBounds = aView->GetBoundsInParentUnits();
       aView->SetDimensions(aRect, true);
       nsViewManager* parentVM = parentView->GetViewManagerInternal();
       if (!aRepaintExposedAreaOnly) {
         // Invalidate the union of the old and new size
@@ -1013,69 +1013,69 @@ NS_IMETHODIMP nsViewManager::ResizeView(
   // region set, then we expect layout to update the clip region too. Thus
   // in the case where mClipRect has been optimized away to just be a null
   // pointer, and this resize is implicitly changing the clip rect, it's OK
   // because layout will change it back again if necessary.
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsViewManager::SetViewFloating(nsIView *aView, bool aFloating)
+NS_IMETHODIMP nsViewManager::SetViewFloating(nsView *aView, bool aFloating)
 {
   NS_ASSERTION(!(nullptr == aView), "no view");
 
   aView->SetFloating(aFloating);
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsViewManager::SetViewVisibility(nsIView *aView, nsViewVisibility aVisible)
+NS_IMETHODIMP nsViewManager::SetViewVisibility(nsView *aView, nsViewVisibility aVisible)
 {
   NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
 
   if (aVisible != aView->GetVisibility()) {
     aView->SetVisibility(aVisible);
 
     if (IsViewInserted(aView)) {
       if (!aView->HasWidget()) {
         if (nsViewVisibility_kHide == aVisible) {
-          nsIView* parentView = aView->GetParent();
+          nsView* parentView = aView->GetParent();
           if (parentView) {
             parentView->GetViewManagerInternal()->
               InvalidateView(parentView, aView->GetBoundsInParentUnits());
           }
         }
         else {
           InvalidateView(aView);
         }
       }
     }
   }
   return NS_OK;
 }
 
-bool nsViewManager::IsViewInserted(nsIView *aView)
+bool nsViewManager::IsViewInserted(nsView *aView)
 {
   if (mRootView == aView) {
     return true;
   } else if (aView->GetParent() == nullptr) {
     return false;
   } else {
-    nsIView* view = aView->GetParent()->GetFirstChild();
+    nsView* view = aView->GetParent()->GetFirstChild();
     while (view != nullptr) {
       if (view == aView) {
         return true;
       }        
       view = view->GetNextSibling();
     }
     return false;
   }
 }
 
-NS_IMETHODIMP nsViewManager::SetViewZIndex(nsIView *aView, bool aAutoZIndex, int32_t aZIndex, bool aTopMost)
+NS_IMETHODIMP nsViewManager::SetViewZIndex(nsView *aView, bool aAutoZIndex, int32_t aZIndex, bool aTopMost)
 {
   nsresult  rv = NS_OK;
 
   NS_ASSERTION((aView != nullptr), "no view");
 
   // don't allow the root view's z-index to be changed. It should always be zero.
   // This could be removed and replaced with a style rule, or just removed altogether, with interesting consequences
   if (aView == mRootView) {
@@ -1139,17 +1139,17 @@ NS_IMETHODIMP nsViewManager::GetRootWidg
     return NS_OK;
   }
   if (mRootView->GetParent())
     return mRootView->GetParent()->GetViewManagerInternal()->GetRootWidget(aWidget);
   *aWidget = nullptr;
   return NS_OK;
 }
 
-nsIntRect nsViewManager::ViewToWidget(nsIView *aView, const nsRect &aRect) const
+nsIntRect nsViewManager::ViewToWidget(nsView *aView, const nsRect &aRect) const
 {
   NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
 
   // account for the view's origin not lining up with the widget's
   nsRect rect = aRect + aView->ViewToWidgetOffset();
 
   // finally, convert to device coordinates.
   return rect.ToOutsidePixels(AppUnitsPerDevPixel());
@@ -1231,17 +1231,17 @@ nsViewManager::GetLastUserEventTime(uint
 
 void
 nsViewManager::InvalidateHierarchy()
 {
   if (mRootView) {
     if (!IsRootVM()) {
       NS_RELEASE(mRootViewManager);
     }
-    nsIView *parent = mRootView->GetParent();
+    nsView *parent = mRootView->GetParent();
     if (parent) {
       mRootViewManager = parent->GetViewManagerInternal()->RootViewManager();
       NS_ADDREF(mRootViewManager);
       NS_ASSERTION(mRootViewManager != this,
                    "Root view had a parent, but it has the same view manager");
     } else {
       mRootViewManager = this;
     }
--- a/view/src/nsViewManager.h
+++ b/view/src/nsViewManager.h
@@ -46,51 +46,51 @@ public:
   nsViewManager();
 
   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
 
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD  Init(nsDeviceContext* aContext);
 
-  NS_IMETHOD_(nsIView*) CreateView(const nsRect& aBounds,
-                                   const nsIView* aParent,
+  NS_IMETHOD_(nsView*) CreateView(const nsRect& aBounds,
+                                   const nsView* aParent,
                                    nsViewVisibility aVisibilityFlag = nsViewVisibility_kShow);
 
-  NS_IMETHOD_(nsIView*) GetRootView();
-  NS_IMETHOD  SetRootView(nsIView *aView);
+  NS_IMETHOD_(nsView*) GetRootView();
+  NS_IMETHOD  SetRootView(nsView *aView);
 
   NS_IMETHOD  GetWindowDimensions(nscoord *width, nscoord *height);
   NS_IMETHOD  SetWindowDimensions(nscoord width, nscoord height);
   NS_IMETHOD  FlushDelayedResize(bool aDoReflow);
 
-  NS_IMETHOD  InvalidateView(nsIView *aView);
-  NS_IMETHOD  InvalidateViewNoSuppression(nsIView *aView, const nsRect &aRect);
+  NS_IMETHOD  InvalidateView(nsView *aView);
+  NS_IMETHOD  InvalidateViewNoSuppression(nsView *aView, const nsRect &aRect);
   NS_IMETHOD  InvalidateAllViews();
 
   NS_IMETHOD  DispatchEvent(nsGUIEvent *aEvent,
-      nsIView* aTargetView, nsEventStatus* aStatus);
+      nsView* aTargetView, nsEventStatus* aStatus);
 
-  NS_IMETHOD  InsertChild(nsIView *parent, nsIView *child, nsIView *sibling,
+  NS_IMETHOD  InsertChild(nsView *parent, nsView *child, nsView *sibling,
                           bool above);
 
-  NS_IMETHOD  InsertChild(nsIView *parent, nsIView *child,
+  NS_IMETHOD  InsertChild(nsView *parent, nsView *child,
                           int32_t zindex);
 
-  NS_IMETHOD  RemoveChild(nsIView *parent);
+  NS_IMETHOD  RemoveChild(nsView *parent);
 
-  NS_IMETHOD  MoveViewTo(nsIView *aView, nscoord aX, nscoord aY);
+  NS_IMETHOD  MoveViewTo(nsView *aView, nscoord aX, nscoord aY);
 
-  NS_IMETHOD  ResizeView(nsIView *aView, const nsRect &aRect, bool aRepaintExposedAreaOnly = false);
+  NS_IMETHOD  ResizeView(nsView *aView, const nsRect &aRect, bool aRepaintExposedAreaOnly = false);
 
-  NS_IMETHOD  SetViewFloating(nsIView *aView, bool aFloating);
+  NS_IMETHOD  SetViewFloating(nsView *aView, bool aFloating);
 
-  NS_IMETHOD  SetViewVisibility(nsIView *aView, nsViewVisibility aVisible);
+  NS_IMETHOD  SetViewVisibility(nsView *aView, nsViewVisibility aVisible);
 
-  NS_IMETHOD  SetViewZIndex(nsIView *aView, bool aAuto, int32_t aZIndex, bool aTopMost=false);
+  NS_IMETHOD  SetViewZIndex(nsView *aView, bool aAuto, int32_t aZIndex, bool aTopMost=false);
 
   virtual void SetPresShell(nsIPresShell *aPresShell) { mPresShell = aPresShell; }
   virtual nsIPresShell* GetPresShell() { return mPresShell; }
 
   NS_IMETHOD  GetDeviceContext(nsDeviceContext *&aContext);
 
   virtual nsIViewManager* IncrementDisableRefreshCount();
   virtual void DecrementDisableRefreshCount();
@@ -108,61 +108,61 @@ public:
   virtual void UpdateWidgetGeometry();
 
 protected:
   virtual ~nsViewManager();
 
 private:
 
   void FlushPendingInvalidates();
-  void ProcessPendingUpdatesForView(nsIView *aView,
+  void ProcessPendingUpdatesForView(nsView *aView,
                                     bool aFlushDirtyRegion = true);
-  void FlushDirtyRegionToWidget(nsIView* aView);
+  void FlushDirtyRegionToWidget(nsView* aView);
   /**
    * Call WillPaint() on all view observers under this vm root.
    */
   void CallWillPaintOnObservers(bool aWillSendDidPaint);
-  void ReparentChildWidgets(nsIView* aView, nsIWidget *aNewWidget);
-  void ReparentWidgets(nsIView* aView, nsIView *aParent);
-  void InvalidateWidgetArea(nsIView *aWidgetView, const nsRegion &aDamagedRegion);
+  void ReparentChildWidgets(nsView* aView, nsIWidget *aNewWidget);
+  void ReparentWidgets(nsView* aView, nsView *aParent);
+  void InvalidateWidgetArea(nsView *aWidgetView, const nsRegion &aDamagedRegion);
 
-  void InvalidateViews(nsIView *aView);
+  void InvalidateViews(nsView *aView);
 
   // aView is the view for aWidget and aRegion is relative to aWidget.
-  void Refresh(nsIView *aView, const nsIntRegion& aRegion, bool aWillSendDidPaint);
+  void Refresh(nsView *aView, const nsIntRegion& aRegion, bool aWillSendDidPaint);
 
-  void InvalidateRectDifference(nsIView *aView, const nsRect& aRect, const nsRect& aCutOut);
-  void InvalidateHorizontalBandDifference(nsIView *aView, const nsRect& aRect, const nsRect& aCutOut,
+  void InvalidateRectDifference(nsView *aView, const nsRect& aRect, const nsRect& aCutOut);
+  void InvalidateHorizontalBandDifference(nsView *aView, const nsRect& aRect, const nsRect& aCutOut,
                                           nscoord aY1, nscoord aY2, bool aInCutOut);
 
   // Utilities
 
-  bool IsViewInserted(nsIView *aView);
+  bool IsViewInserted(nsView *aView);
 
   /**
    * Intersects aRect with aView's bounds and then transforms it from aView's
    * coordinate system to the coordinate system of the widget attached to
    * aView.
    */
-  nsIntRect ViewToWidget(nsIView *aView, const nsRect &aRect) const;
+  nsIntRect ViewToWidget(nsView *aView, const nsRect &aRect) const;
 
   void DoSetWindowDimensions(nscoord aWidth, nscoord aHeight);
 
   bool IsPainting() const {
     return RootViewManager()->mPainting;
   }
 
   void SetPainting(bool aPainting) {
     RootViewManager()->mPainting = aPainting;
   }
 
-  nsresult InvalidateView(nsIView *aView, const nsRect &aRect);
+  nsresult InvalidateView(nsView *aView, const nsRect &aRect);
 
 public: // NOT in nsIViewManager, so private to the view module
-  nsIView* GetRootViewImpl() const { return mRootView; }
+  nsView* GetRootViewImpl() const { return mRootView; }
   nsViewManager* RootViewManager() const { return mRootViewManager; }
   bool IsRootVM() const { return this == RootViewManager(); }
 
   // Whether synchronous painting is allowed at the moment. For example,
   // widget geometry changes can cause synchronous painting, so they need to
   // be deferred while refresh is disabled.
   bool IsPaintingAllowed() { return RootViewManager()->mRefreshDisableCount == 0; }
 
@@ -183,17 +183,17 @@ public: // NOT in nsIViewManager, so pri
 private:
   nsRefPtr<nsDeviceContext> mContext;
   nsIPresShell   *mPresShell;
 
   // The size for a resize that we delayed until the root view becomes
   // visible again.
   nsSize            mDelayedResize;
 
-  nsIView           *mRootView;
+  nsView           *mRootView;
   // mRootViewManager is a strong ref unless it equals |this|.  It's
   // never null (if we have no ancestors, it will be |this|).
   nsViewManager     *mRootViewManager;
 
   // The following members should not be accessed directly except by
   // the root view manager.  Some have accessor functions to enforce
   // this, as noted.
   
--- a/widget/cocoa/nsDragService.mm
+++ b/widget/cocoa/nsDragService.mm
@@ -22,17 +22,17 @@
 #include "nsIDOMNode.h"
 #include "nsRect.h"
 #include "nsPoint.h"
 #include "nsICharsetConverterManager.h"
 #include "nsIIOService.h"
 #include "nsNetUtil.h"
 #include "nsIDocument.h"
 #include "nsIContent.h"
-#include "nsIView.h"
+#include "nsView.h"
 #include "gfxASurface.h"
 #include "gfxContext.h"
 #include "nsCocoaUtils.h"
 
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* sCocoaLog;
 #endif
 
--- a/widget/nsIWidget.h
+++ b/widget/nsIWidget.h
@@ -519,17 +519,17 @@ class nsIWidget : public nsISupports {
      * instead of the normal listener.
      * aContext The new device context for the view
      */
     NS_IMETHOD AttachViewToTopLevel(bool aUseAttachedEvents,
                                     nsDeviceContext *aContext) = 0;
 
     /**
      * Accessor functions to get and set the attached listener. Used by
-     * nsIView in connection with AttachViewToTopLevel above.
+     * nsView in connection with AttachViewToTopLevel above.
      */
     virtual void SetAttachedWidgetListener(nsIWidgetListener* aListener) = 0;
     virtual nsIWidgetListener* GetAttachedWidgetListener() = 0;
 
     /**
      * Accessor functions to get and set the listener which handles various
      * actions for the widget.
      */
--- a/widget/nsIWidgetListener.h
+++ b/widget/nsIWidgetListener.h
@@ -35,34 +35,34 @@
 
 #ifndef nsIWidgetListener_h__
 #define nsIWidgetListener_h__
 
 #include "nscore.h"
 #include "nsGUIEvent.h"
 #include "nsIXULWindow.h"
 
-class nsIView;
+class nsView;
 class nsIPresShell;
 
 class nsIWidgetListener
 {
 public:
 
   /**
    * If this listener is for an nsIXULWindow, return it. If this is null, then
    * this is likely a listener for a view, which can be determined using
    * GetView. If both methods return null, this will be an nsWebBrowser.
    */
   virtual nsIXULWindow* GetXULWindow() { return nullptr; }
 
   /**
-   * If this listener is for an nsIView, return it.
+   * If this listener is for an nsView, return it.
    */
-  virtual nsIView* GetView() { return nullptr; }
+  virtual nsView* GetView() { return nullptr; }
 
   /**
    * Return the presshell for this widget listener.
    */
   virtual nsIPresShell* GetPresShell() { return nullptr; }
 
   /**
    * Called when a window is moved to location (x, y). Returns true if the