The Tor Browser: comparison content/base/public/nsIFrameLoader.idl

--1:000000000000
+:1b847f969c2a
+/* -*- Mode: IDL; 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 "nsISupports.idl"
+interface nsFrameLoader;
+interface nsIDocShell;
+interface nsIURI;
+interface nsIFrame;
+interface nsSubDocumentFrame;
+interface nsIMessageSender;
+interface nsIVariant;
+interface nsIDOMElement;
+interface nsITabParent;
+interface nsILoadContext;
+typedef unsigned long long nsContentViewId;
+/**
+* These interfaces do *not* scroll or scale the content document;
+* instead they set a "goal" scroll/scale wrt the current content
+* view.  When the content document is painted, the scroll*
+* attributes are used to set a compensating transform.  If the
+* metrics of the content document's current pixels don't match the
+* view config, the transform matrix may need to translate
+* content pixels and/or perform a "fuzzy-scale" that doesn't
+* re-rasterize fonts or intelligently resample images.
+*
+* The attrs are allowed to transform content pixels in
+* such a way that the <browser>'s visible rect encloses pixels that
+* the content document does not (yet) define.
+*
+* The view scroll values are in units of chrome-document CSS
+* pixels.
+*
+* These APIs are designed to be used with nsIDOMWindowUtils
+* setDisplayPort() and setResolution().
+*/
+[scriptable, uuid(c04c5c40-fa2a-4e9c-94f5-b362a10a86cb)]
+interface nsIContentView : nsISupports
+{
+/**
+* Scroll view to or by the given chrome-document CSS pixels.
+* Fails if the view is no longer valid.
+*/
+void scrollTo(in float xPx, in float yPx);
+void scrollBy(in float dxPx, in float dyPx);
+void setScale(in float xScale, in float yScale);
+/**
+* Scroll offset in chrome-document CSS pixels.
+*
+* When this view is active (i.e. it is being painted because it's in the
+* visible region of the screen), this value is at first lined up with the
+* content's scroll offset.
+*
+* Note that when this view becomes inactive, the new content view will have
+* scroll values that are reset to the default!
+*/
+readonly attribute float scrollX;
+readonly attribute float scrollY;
+/**
+* Dimensions of the viewport in chrome-document CSS pixels.
+*/
+readonly attribute float viewportWidth;
+readonly attribute float viewportHeight;
+/**
+* Dimensions of scrolled content in chrome-document CSS pixels.
+*/
+readonly attribute float contentWidth;
+readonly attribute float contentHeight;
+/**
+* ID that can be used in conjunction with nsIDOMWindowUtils to change
+* the actual document, instead of just how it is transformed.
+*/
+readonly attribute nsContentViewId id;
+};
+[scriptable, uuid(ba5af90d-ece5-40b2-9a1d-a0154128db1c)]
+interface nsIContentViewManager : nsISupports
+{
+/**
+* Retrieve view scrolling/scaling interfaces in a given area,
+* used to support asynchronous re-paints of content pixels.
+* These interfaces are only meaningful for <browser>.
+*
+* Pixels are in chrome device pixels and are relative to the browser
+* element.
+*
+* @param aX x coordinate that will be in target rectangle
+* @param aY y coordinate that will be in target rectangle
+* @param aTopSize How much to expand up the rectangle
+* @param aRightSize How much to expand right the rectangle
+* @param aBottomSize How much to expand down the rectangle
+* @param aLeftSize How much to expand left the rectangle
+*/
+void getContentViewsIn(in float aXPx, in float aYPx,
+in float aTopSize, in float aRightSize,
+in float aBottomSize, in float aLeftSize,
+[optional] out unsigned long aLength,
+[retval, array, size_is(aLength)] out nsIContentView aResult);
+/**
+* The root content view.
+*/
+readonly attribute nsIContentView rootContentView;
+};
+[scriptable, builtinclass, uuid(a5cefcc8-551b-4901-83f3-7436b09ecaba)]
+interface nsIFrameLoader : nsISupports
+{
+/**
+* Get the docshell from the frame loader.
+*/
+readonly attribute nsIDocShell docShell;
+/**
+* Get this frame loader's TabParent, if it has a remote frame.  Otherwise,
+* returns null.
+*/
+readonly attribute nsITabParent tabParent;
+/**
+* Get an nsILoadContext for the top-level docshell. For remote
+* frames, a shim is returned that contains private browsing and app
+* information.
+*/
+readonly attribute nsILoadContext loadContext;
+/**
+* Start loading the frame. This method figures out what to load
+* from the owner content in the frame loader.
+*/
+void loadFrame();
+/**
+* Loads the specified URI in this frame. Behaves identically to loadFrame,
+* except that this method allows specifying the URI to load.
+*/
+void loadURI(in nsIURI aURI);
+/**
+* Destroy the frame loader and everything inside it. This will
+* clear the weak owner content reference.
+*/
+void destroy();
+/**
+* Find out whether the loader's frame is at too great a depth in
+* the frame tree.  This can be used to decide what operations may
+* or may not be allowed on the loader's docshell.
+*/
+readonly attribute boolean depthTooGreat;
+/**
+* Updates the position and size of the subdocument loaded by this frameloader.
+*
+*  @param aIFrame The nsIFrame for the content node that owns this frameloader
+*/
+[noscript] void updatePositionAndSize(in nsSubDocumentFrame aIFrame);
+/**
+* Activate remote frame.
+* Throws an exception with non-remote frames.
+*/
+void activateRemoteFrame();
+/**
+* Deactivate remote frame.
+* Throws an exception with non-remote frames.
+*/
+void deactivateRemoteFrame();
+/**
+* @see nsIDOMWindowUtils sendMouseEvent.
+*/
+void sendCrossProcessMouseEvent(in AString aType,
+in float aX,
+in float aY,
+in long aButton,
+in long aClickCount,
+in long aModifiers,
+[optional] in boolean aIgnoreRootScrollFrame);
+/**
+* Activate event forwarding from client (remote frame) to parent.
+*/
+void activateFrameEvent(in AString aType, in boolean capture);
+// Note, when frameloaders are swapped, also messageManagers are swapped.
+readonly attribute nsIMessageSender messageManager;
+/**
+* @see nsIDOMWindowUtils sendKeyEvent.
+*/
+void sendCrossProcessKeyEvent(in AString aType,
+in long aKeyCode,
+in long aCharCode,
+in long aModifiers,
+[optional] in boolean aPreventDefault);
+/**
+* The default rendering mode is synchronous scrolling.  In this
+* mode, it's an error to try to set a target viewport.
+*/
+const unsigned long RENDER_MODE_DEFAULT        = 0x00000000;
+/**
+* When asynchronous scrolling is enabled, a target viewport can be
+* set to transform content pixels wrt its CSS viewport.
+*
+* NB: when async scrolling is enabled, it's the *user's*
+* responsibility to update the target scroll offset.  In effect,
+* the platform hands over control of scroll offset to the user.
+*/
+const unsigned long RENDER_MODE_ASYNC_SCROLL   = 0x00000001;
+attribute unsigned long renderMode;
+/**
+* The default event mode automatically forwards the events
+* handled in EventStateManager::HandleCrossProcessEvent to
+* the child content process when these events are targeted to
+* the remote browser element.
+*
+* Used primarly for input events (mouse, keyboard)
+*/
+const unsigned long EVENT_MODE_NORMAL_DISPATCH = 0x00000000;
+/**
+* With this event mode, it's the application's responsability to
+* convert and forward events to the content process
+*/
+const unsigned long EVENT_MODE_DONT_FORWARD_TO_CHILD = 0x00000001;
+attribute unsigned long eventMode;
+/**
+* If false, then the subdocument is not clipped to its CSS viewport, and the
+* subdocument's viewport scrollbar(s) are not rendered.
+* Defaults to true.
+*/
+attribute boolean clipSubdocument;
+/**
+* If false, then the subdocument's scroll coordinates will not be clamped
+* to their scroll boundaries.
+* Defaults to true.
+*/
+attribute boolean clampScrollPosition;
+/**
+* The element which owns this frame loader.
+*
+* For example, if this is a frame loader for an <iframe>, this attribute
+* returns the iframe element.
+*/
+readonly attribute nsIDOMElement ownerElement;
+/**
+* Cached childID of the ContentParent owning the TabParent in this frame
+* loader. This can be used to obtain the childID after the TabParent died.
+*/
+readonly attribute unsigned long long childID;
+/**
+* Get or set this frame loader's visibility.
+*
+* The notion of "visibility" here is separate from the notion of a
+* window/docshell's visibility.  This field is mostly here so that we can
+* have a notion of visibility in the parent process when frames are OOP.
+*/
+[infallible] attribute boolean visible;
+/**
+* Find out whether the owner content really is a browser or app frame
+*/
+readonly attribute boolean ownerIsBrowserOrAppFrame;
+};
+%{C++
+class nsFrameLoader;
+%}
+native alreadyAddRefed_nsFrameLoader(already_AddRefed<nsFrameLoader>);
+[scriptable, uuid(5879040e-83e9-40e3-b2bb-5ddf43b76e47)]
+interface nsIFrameLoaderOwner : nsISupports
+{
+/**
+* The frame loader owned by this nsIFrameLoaderOwner
+*/
+readonly attribute nsIFrameLoader frameLoader;
+[noscript, notxpcom] alreadyAddRefed_nsFrameLoader GetFrameLoader();
+/**
+* Swap frame loaders with the given nsIFrameLoaderOwner.  This may
+* only be posible in a very limited range of circumstances, or
+* never, depending on the object implementing this interface.
+*
+* @throws NS_ERROR_NOT_IMPLEMENTED if the swapping logic is not
+*   implemented for the two given frame loader owners.
+* @throws NS_ERROR_DOM_SECURITY_ERR if the swap is not allowed on
+*   security grounds.
+*/
+void swapFrameLoaders(in nsIFrameLoaderOwner aOtherOwner);
+};

The Tor Browser / file comparison

comparison: content/base/public/nsIFrameLoader.idl

content/base/public/nsIFrameLoader.idl