| /* |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef WebFrame_h |
| #define WebFrame_h |
| |
| #include "WebIconURL.h" |
| #include "WebNode.h" |
| #include "WebURLLoaderOptions.h" |
| #include "public/platform/WebCanvas.h" |
| #include "public/platform/WebInsecureRequestPolicy.h" |
| #include "public/web/WebFrameLoadType.h" |
| #include "public/web/WebTreeScopeType.h" |
| #include <memory> |
| |
| struct NPObject; |
| |
| namespace v8 { |
| class Context; |
| class Function; |
| class Object; |
| class Value; |
| template <class T> |
| class Local; |
| } |
| |
| namespace blink { |
| |
| class Frame; |
| class OpenedFrameTracker; |
| class Visitor; |
| class WebDOMEvent; |
| class WebData; |
| class WebDataSource; |
| class WebDocument; |
| class WebElement; |
| class WebFrameImplBase; |
| class WebLayer; |
| class WebLocalFrame; |
| class WebPerformance; |
| class WebRemoteFrame; |
| class WebSecurityOrigin; |
| class WebSharedWorkerRepositoryClient; |
| class WebString; |
| class WebURL; |
| class WebURLLoader; |
| class WebURLRequest; |
| class WebView; |
| enum class WebSandboxFlags; |
| struct WebConsoleMessage; |
| struct WebFrameOwnerProperties; |
| struct WebPrintParams; |
| struct WebRect; |
| struct WebScriptSource; |
| struct WebSize; |
| |
| template <typename T> |
| class WebVector; |
| |
| // Frames may be rendered in process ('local') or out of process ('remote'). |
| // A remote frame is always cross-site; a local frame may be either same-site or |
| // cross-site. |
| // WebFrame is the base class for both WebLocalFrame and WebRemoteFrame and |
| // contains methods that are valid on both local and remote frames, such as |
| // getting a frame's parent or its opener. |
| class WebFrame { |
| public: |
| // FIXME: We already have blink::TextGranularity. For now we support only |
| // a part of blink::TextGranularity. |
| // Ideally it seems blink::TextGranularity should be broken up into |
| // blink::TextGranularity and perhaps blink::TextBoundary and then |
| // TextGranularity enum could be moved somewhere to public/, and we could |
| // just use it here directly without introducing a new enum. |
| enum TextGranularity { |
| CharacterGranularity = 0, |
| WordGranularity, |
| TextGranularityLast = WordGranularity, |
| }; |
| |
| // Returns the number of live WebFrame objects, used for leak checking. |
| BLINK_EXPORT static int instanceCount(); |
| |
| virtual bool isWebLocalFrame() const = 0; |
| virtual WebLocalFrame* toWebLocalFrame() = 0; |
| virtual bool isWebRemoteFrame() const = 0; |
| virtual WebRemoteFrame* toWebRemoteFrame() = 0; |
| |
| BLINK_EXPORT bool swap(WebFrame*); |
| |
| // This method closes and deletes the WebFrame. This is typically called by |
| // the embedder in response to a frame detached callback to the WebFrame |
| // client. |
| virtual void close() = 0; |
| |
| // Called by the embedder when it needs to detach the subtree rooted at this |
| // frame. |
| BLINK_EXPORT void detach(); |
| |
| // Basic properties --------------------------------------------------- |
| |
| // The unique name of this frame. |
| virtual WebString uniqueName() const = 0; |
| |
| // The name of this frame. If no name is given, empty string is returned. |
| virtual WebString assignedName() const = 0; |
| |
| // Sets the name of this frame. For child frames (frames that are not a |
| // top-most frame) the actual name may have a suffix appended to make the |
| // frame name unique within the hierarchy. |
| virtual void setName(const WebString&) = 0; |
| |
| // The urls of the given combination types of favicon (if any) specified by |
| // the document loaded in this frame. The iconTypesMask is a bit-mask of |
| // WebIconURL::Type values, used to select from the available set of icon |
| // URLs |
| virtual WebVector<WebIconURL> iconURLs(int iconTypesMask) const = 0; |
| |
| // For a WebFrame with contents being rendered in another process, this |
| // sets a layer for use by the in-process compositor. WebLayer should be |
| // null if the content is being rendered in the current process. |
| virtual void setRemoteWebLayer(WebLayer*) = 0; |
| |
| // Initializes the various client interfaces. |
| virtual void setSharedWorkerRepositoryClient( |
| WebSharedWorkerRepositoryClient*) = 0; |
| |
| // The security origin of this frame. |
| BLINK_EXPORT WebSecurityOrigin getSecurityOrigin() const; |
| |
| // Updates the sandbox flags in the frame's FrameOwner. This is used when |
| // this frame's parent is in another process and it dynamically updates |
| // this frame's sandbox flags. The flags won't take effect until the next |
| // navigation. |
| BLINK_EXPORT void setFrameOwnerSandboxFlags(WebSandboxFlags); |
| |
| // The frame's insecure request policy. |
| BLINK_EXPORT WebInsecureRequestPolicy getInsecureRequestPolicy() const; |
| |
| // Updates this frame's FrameOwner properties, such as scrolling, margin, |
| // or allowfullscreen. This is used when this frame's parent is in |
| // another process and it dynamically updates these properties. |
| // TODO(dcheng): Currently, the update only takes effect on next frame |
| // navigation. This matches the in-process frame behavior. |
| BLINK_EXPORT void setFrameOwnerProperties(const WebFrameOwnerProperties&); |
| |
| // Geometry ----------------------------------------------------------- |
| |
| // NOTE: These routines do not force page layout so their results may |
| // not be accurate if the page layout is out-of-date. |
| |
| // If set to false, do not draw scrollbars on this frame's view. |
| virtual void setCanHaveScrollbars(bool) = 0; |
| |
| // The scroll offset from the top-left corner of the frame in pixels. |
| virtual WebSize scrollOffset() const = 0; |
| virtual void setScrollOffset(const WebSize&) = 0; |
| |
| // The size of the contents area. |
| virtual WebSize contentsSize() const = 0; |
| |
| // Returns true if the contents (minus scrollbars) has non-zero area. |
| virtual bool hasVisibleContent() const = 0; |
| |
| // Returns the visible content rect (minus scrollbars, in absolute coordinate) |
| virtual WebRect visibleContentRect() const = 0; |
| |
| virtual bool hasHorizontalScrollbar() const = 0; |
| virtual bool hasVerticalScrollbar() const = 0; |
| |
| // Hierarchy ---------------------------------------------------------- |
| |
| // Returns the containing view. |
| virtual WebView* view() const = 0; |
| |
| // Returns the frame that opened this frame or 0 if there is none. |
| BLINK_EXPORT WebFrame* opener() const; |
| |
| // Sets the frame that opened this one or 0 if there is none. |
| BLINK_EXPORT void setOpener(WebFrame*); |
| |
| // Reset the frame that opened this frame to 0. |
| // This is executed between layout tests runs |
| void clearOpener() { setOpener(0); } |
| |
| // Inserts the given frame as a child of this frame, so that it is the next |
| // child after |previousSibling|, or first child if |previousSibling| is null. |
| BLINK_EXPORT void insertAfter(WebFrame* child, WebFrame* previousSibling); |
| |
| // Adds the given frame as a child of this frame. |
| BLINK_EXPORT void appendChild(WebFrame*); |
| |
| // Removes the given child from this frame. |
| BLINK_EXPORT void removeChild(WebFrame*); |
| |
| // Returns the parent frame or 0 if this is a top-most frame. |
| BLINK_EXPORT WebFrame* parent() const; |
| |
| // Returns the top-most frame in the hierarchy containing this frame. |
| BLINK_EXPORT WebFrame* top() const; |
| |
| // Returns the first/last child frame. |
| BLINK_EXPORT WebFrame* firstChild() const; |
| BLINK_EXPORT WebFrame* lastChild() const; |
| |
| // Returns the previous/next sibling frame. |
| BLINK_EXPORT WebFrame* previousSibling() const; |
| BLINK_EXPORT WebFrame* nextSibling() const; |
| |
| // Returns the previous/next frame in "frame traversal order", |
| // optionally wrapping around. |
| BLINK_EXPORT WebFrame* traversePrevious(bool wrap) const; |
| BLINK_EXPORT WebFrame* traverseNext(bool wrap) const; |
| |
| // Returns the child frame identified by the given name. |
| BLINK_EXPORT WebFrame* findChildByName(const WebString& name) const; |
| |
| // Content ------------------------------------------------------------ |
| |
| virtual WebDocument document() const = 0; |
| |
| virtual WebPerformance performance() const = 0; |
| |
| // Closing ------------------------------------------------------------- |
| |
| // Runs unload handlers for this frame. |
| virtual void dispatchUnloadEvent() = 0; |
| |
| // Scripting ---------------------------------------------------------- |
| |
| // Executes script in the context of the current page. |
| virtual void executeScript(const WebScriptSource&) = 0; |
| |
| // Executes JavaScript in a new world associated with the web frame. |
| // The script gets its own global scope and its own prototypes for |
| // intrinsic JavaScript objects (String, Array, and so-on). It also |
| // gets its own wrappers for all DOM nodes and DOM constructors. |
| // extensionGroup is an embedder-provided specifier that controls which |
| // v8 extensions are loaded into the new context - see |
| // blink::registerExtension for the corresponding specifier. |
| // |
| // worldID must be > 0 (as 0 represents the main world). |
| // worldID must be < EmbedderWorldIdLimit, high number used internally. |
| virtual void executeScriptInIsolatedWorld(int worldID, |
| const WebScriptSource* sources, |
| unsigned numSources, |
| int extensionGroup) = 0; |
| |
| // Associates an isolated world (see above for description) with a security |
| // origin. XMLHttpRequest instances used in that world will be considered |
| // to come from that origin, not the frame's. |
| virtual void setIsolatedWorldSecurityOrigin(int worldID, |
| const WebSecurityOrigin&) = 0; |
| |
| // Associates a content security policy with an isolated world. This policy |
| // should be used when evaluating script in the isolated world, and should |
| // also replace a protected resource's CSP when evaluating resources |
| // injected into the DOM. |
| // |
| // FIXME: Setting this simply bypasses the protected resource's CSP. It |
| // doesn't yet restrict the isolated world to the provided policy. |
| virtual void setIsolatedWorldContentSecurityPolicy(int worldID, |
| const WebString&) = 0; |
| |
| // Logs to the console associated with this frame. |
| virtual void addMessageToConsole(const WebConsoleMessage&) = 0; |
| |
| // Calls window.gc() if it is defined. |
| virtual void collectGarbage() = 0; |
| |
| // Executes script in the context of the current page and returns the value |
| // that the script evaluated to. |
| // DEPRECATED: Use WebLocalFrame::requestExecuteScriptAndReturnValue. |
| virtual v8::Local<v8::Value> executeScriptAndReturnValue( |
| const WebScriptSource&) = 0; |
| |
| // worldID must be > 0 (as 0 represents the main world). |
| // worldID must be < EmbedderWorldIdLimit, high number used internally. |
| // DEPRECATED: Use WebLocalFrame::requestExecuteScriptInIsolatedWorld. |
| virtual void executeScriptInIsolatedWorld( |
| int worldID, |
| const WebScriptSource* sourcesIn, |
| unsigned numSources, |
| int extensionGroup, |
| WebVector<v8::Local<v8::Value>>* results) = 0; |
| |
| // Call the function with the given receiver and arguments, bypassing |
| // canExecute(). |
| virtual v8::Local<v8::Value> callFunctionEvenIfScriptDisabled( |
| v8::Local<v8::Function>, |
| v8::Local<v8::Value>, |
| int argc, |
| v8::Local<v8::Value> argv[]) = 0; |
| |
| // Returns the V8 context for associated with the main world and this |
| // frame. There can be many V8 contexts associated with this frame, one for |
| // each isolated world and one for the main world. If you don't know what |
| // the "main world" or an "isolated world" is, then you probably shouldn't |
| // be calling this API. |
| virtual v8::Local<v8::Context> mainWorldScriptContext() const = 0; |
| |
| // Returns true if the WebFrame currently executing JavaScript has access |
| // to the given WebFrame, or false otherwise. |
| BLINK_EXPORT static bool scriptCanAccess(WebFrame*); |
| |
| // Navigation ---------------------------------------------------------- |
| // TODO(clamy): Remove the reload, reloadWithOverrideURL, and loadRequest |
| // functions once RenderFrame only calls WebLoadFrame::load. |
| |
| // Reload the current document. |
| // Note: reload() and reloadWithOverrideURL() will be deprecated. |
| // Do not use these APIs any more, but use loadRequest() instead. |
| virtual void reload(WebFrameLoadType = WebFrameLoadType::Reload) = 0; |
| |
| // This is used for situations where we want to reload a different URL because |
| // of a redirect. |
| virtual void reloadWithOverrideURL( |
| const WebURL& overrideUrl, |
| WebFrameLoadType = WebFrameLoadType::Reload) = 0; |
| |
| // Load the given URL. |
| virtual void loadRequest(const WebURLRequest&) = 0; |
| |
| // This method is short-hand for calling LoadData, where mime_type is |
| // "text/html" and text_encoding is "UTF-8". |
| virtual void loadHTMLString(const WebData& html, |
| const WebURL& baseURL, |
| const WebURL& unreachableURL = WebURL(), |
| bool replace = false) = 0; |
| |
| // Stops any pending loads on the frame and its children. |
| virtual void stopLoading() = 0; |
| |
| // Returns the data source that is currently loading. May be null. |
| virtual WebDataSource* provisionalDataSource() const = 0; |
| |
| // Returns the data source that is currently loaded. |
| virtual WebDataSource* dataSource() const = 0; |
| |
| // View-source rendering mode. Set this before loading an URL to cause |
| // it to be rendered in view-source mode. |
| virtual void enableViewSourceMode(bool) = 0; |
| virtual bool isViewSourceModeEnabled() const = 0; |
| |
| // Sets the referrer for the given request to be the specified URL or |
| // if that is null, then it sets the referrer to the referrer that the |
| // frame would use for subresources. NOTE: This method also filters |
| // out invalid referrers (e.g., it is invalid to send a HTTPS URL as |
| // the referrer for a HTTP request). |
| virtual void setReferrerForRequest(WebURLRequest&, const WebURL&) = 0; |
| |
| // Called to associate the WebURLRequest with this frame. The request |
| // will be modified to inherit parameters that allow it to be loaded. |
| // This method ends up triggering WebFrameClient::willSendRequest. |
| // DEPRECATED: Please use createAssociatedURLLoader instead. |
| virtual void dispatchWillSendRequest(WebURLRequest&) = 0; |
| |
| // Returns a WebURLLoader that is associated with this frame. The loader |
| // will, for example, be cancelled when WebFrame::stopLoading is called. |
| // FIXME: stopLoading does not yet cancel an associated loader!! |
| virtual WebURLLoader* createAssociatedURLLoader( |
| const WebURLLoaderOptions& = WebURLLoaderOptions()) = 0; |
| |
| // Returns the number of registered unload listeners. |
| virtual unsigned unloadListenerCount() const = 0; |
| |
| // Will return true if between didStartLoading and didStopLoading |
| // notifications. |
| virtual bool isLoading() const; |
| |
| // Printing ------------------------------------------------------------ |
| |
| // Reformats the WebFrame for printing. WebPrintParams specifies the printable |
| // content size, paper size, printable area size, printer DPI and print |
| // scaling option. If constrainToNode node is specified, then only the given |
| // node is printed (for now only plugins are supported), instead of the entire |
| // frame. |
| // Returns the number of pages that can be printed at the given |
| // page size. |
| virtual int printBegin(const WebPrintParams&, |
| const WebNode& constrainToNode = WebNode()) = 0; |
| |
| // Returns the page shrinking factor calculated by webkit (usually |
| // between 1/1.33 and 1/2). Returns 0 if the page number is invalid or |
| // not in printing mode. |
| virtual float getPrintPageShrink(int page) = 0; |
| |
| // Prints one page, and returns the calculated page shrinking factor |
| // (usually between 1/1.33 and 1/2). Returns 0 if the page number is |
| // invalid or not in printing mode. |
| virtual float printPage(int pageToPrint, WebCanvas*) = 0; |
| |
| // Reformats the WebFrame for screen display. |
| virtual void printEnd() = 0; |
| |
| // If the frame contains a full-frame plugin or the given node refers to a |
| // plugin whose content indicates that printed output should not be scaled, |
| // return true, otherwise return false. |
| virtual bool isPrintScalingDisabledForPlugin(const WebNode& = WebNode()) = 0; |
| |
| // Events -------------------------------------------------------------- |
| |
| // Dispatches a message event on the current DOMWindow in this WebFrame. |
| virtual void dispatchMessageEventWithOriginCheck( |
| const WebSecurityOrigin& intendedTargetOrigin, |
| const WebDOMEvent&) = 0; |
| |
| // Utility ------------------------------------------------------------- |
| |
| // Prints all of the pages into the canvas, with page boundaries drawn as |
| // one pixel wide blue lines. This method exists to support layout tests. |
| virtual void printPagesWithBoundaries(WebCanvas*, const WebSize&) = 0; |
| |
| // Returns the bounds rect for current selection. If selection is performed |
| // on transformed text, the rect will still bound the selection but will |
| // not be transformed itself. If no selection is present, the rect will be |
| // empty ((0,0), (0,0)). |
| virtual WebRect selectionBoundsRect() const = 0; |
| |
| // Only for testing purpose: |
| // Returns true if selection.anchorNode has a marker on range from |from| with |
| // |length|. |
| virtual bool selectionStartHasSpellingMarkerFor(int from, |
| int length) const = 0; |
| |
| // Dumps the layer tree, used by the accelerated compositor, in |
| // text form. This is used only by layout tests. |
| virtual WebString layerTreeAsText(bool showDebugInfo = false) const = 0; |
| |
| virtual WebFrameImplBase* toImplBase() = 0; |
| // TODO(dcheng): Fix const-correctness issues and remove this overload. |
| virtual const WebFrameImplBase* toImplBase() const { |
| return const_cast<WebFrame*>(this)->toImplBase(); |
| } |
| |
| // Returns the frame inside a given frame or iframe element. Returns 0 if |
| // the given element is not a frame, iframe or if the frame is empty. |
| BLINK_EXPORT static WebFrame* fromFrameOwnerElement(const WebElement&); |
| |
| #if BLINK_IMPLEMENTATION |
| static WebFrame* fromFrame(Frame*); |
| |
| bool inShadowTree() const { return m_scope == WebTreeScopeType::Shadow; } |
| |
| static void traceFrames(Visitor*, WebFrame*); |
| static void traceFrames(InlinedGlobalMarkingVisitor, WebFrame*); |
| void clearWeakFrames(Visitor*); |
| void clearWeakFrames(InlinedGlobalMarkingVisitor); |
| #endif |
| |
| protected: |
| explicit WebFrame(WebTreeScopeType); |
| virtual ~WebFrame(); |
| |
| // Sets the parent WITHOUT fulling adding it to the frame tree. |
| // Used to lie to a local frame that is replacing a remote frame, |
| // so it can properly start a navigation but wait to swap until |
| // commit-time. |
| void setParent(WebFrame*); |
| |
| private: |
| #if BLINK_IMPLEMENTATION |
| friend class OpenedFrameTracker; |
| |
| static void traceFrame(Visitor*, WebFrame*); |
| static void traceFrame(InlinedGlobalMarkingVisitor, WebFrame*); |
| static bool isFrameAlive(const WebFrame*); |
| |
| template <typename VisitorDispatcher> |
| static void traceFramesImpl(VisitorDispatcher, WebFrame*); |
| template <typename VisitorDispatcher> |
| void clearWeakFramesImpl(VisitorDispatcher); |
| template <typename VisitorDispatcher> |
| static void traceFrameImpl(VisitorDispatcher, WebFrame*); |
| #endif |
| |
| const WebTreeScopeType m_scope; |
| |
| WebFrame* m_parent; |
| WebFrame* m_previousSibling; |
| WebFrame* m_nextSibling; |
| WebFrame* m_firstChild; |
| WebFrame* m_lastChild; |
| |
| WebFrame* m_opener; |
| std::unique_ptr<OpenedFrameTracker> m_openedFrameTracker; |
| }; |
| |
| } // namespace blink |
| |
| #endif |