--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/chromium/public/WebFrameClient.h Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2010 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 WebFrameClient_h
+#define WebFrameClient_h
+
+#include "WebCommon.h"
+#include "WebNavigationPolicy.h"
+#include "WebNavigationType.h"
+#include "WebURLError.h"
+
+namespace WebKit {
+
+class WebApplicationCacheHost;
+class WebApplicationCacheHostClient;
+class WebCookieJar;
+class WebDataSource;
+class WebFormElement;
+class WebFrame;
+class WebMediaPlayer;
+class WebMediaPlayerClient;
+class WebNode;
+class WebPlugin;
+class WebSecurityOrigin;
+class WebSharedWorker;
+class WebString;
+class WebURL;
+class WebURLRequest;
+class WebURLResponse;
+class WebWorker;
+class WebWorkerClient;
+struct WebPluginParams;
+struct WebRect;
+struct WebSize;
+struct WebURLError;
+
+class WebFrameClient {
+public:
+ // Factory methods -----------------------------------------------------
+
+ // May return null.
+ virtual WebPlugin* createPlugin(WebFrame*, const WebPluginParams&) { return 0; }
+
+ // May return null.
+ virtual WebWorker* createWorker(WebFrame*, WebWorkerClient*) { return 0; }
+
+ // May return null.
+ virtual WebSharedWorker* createSharedWorker(WebFrame*, const WebURL&, const WebString&, unsigned long long) { return 0; }
+
+ // May return null.
+ virtual WebMediaPlayer* createMediaPlayer(WebFrame*, WebMediaPlayerClient*) { return 0; }
+
+ // May return null.
+ virtual WebApplicationCacheHost* createApplicationCacheHost(WebFrame*, WebApplicationCacheHostClient*) { return 0; }
+
+
+ // Services ------------------------------------------------------------
+
+ // A frame specific cookie jar. May return null, in which case
+ // WebKitClient::cookieJar() will be called to access cookies.
+ virtual WebCookieJar* cookieJar() { return 0; }
+
+
+ // General notifications -----------------------------------------------
+
+ // This frame is about to be closed.
+ virtual void willClose(WebFrame*) { }
+
+ // Controls whether plugins are allowed for this frame.
+ virtual bool allowPlugins(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; }
+
+ // Notifies the client that the frame would have instantiated a plug-in if plug-ins were enabled.
+ virtual void didNotAllowPlugins(WebFrame*) { }
+
+ // Controls whether images are allowed for this frame.
+ virtual bool allowImages(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; }
+
+
+ // Load commands -------------------------------------------------------
+
+ // The client should handle the navigation externally.
+ virtual void loadURLExternally(
+ WebFrame*, const WebURLRequest&, WebNavigationPolicy) { }
+
+
+ // Navigational queries ------------------------------------------------
+
+ // The client may choose to alter the navigation policy. Otherwise,
+ // defaultPolicy should just be returned.
+ virtual WebNavigationPolicy decidePolicyForNavigation(
+ WebFrame*, const WebURLRequest&, WebNavigationType,
+ const WebNode& originatingNode,
+ WebNavigationPolicy defaultPolicy, bool isRedirect) { return defaultPolicy; }
+
+ // Query if the specified request can be handled.
+ virtual bool canHandleRequest(
+ WebFrame*, const WebURLRequest& request) { return true; }
+
+ // Returns an error corresponding to canHandledRequest() returning false.
+ virtual WebURLError cannotHandleRequestError(
+ WebFrame*, const WebURLRequest& request) { return WebURLError(); }
+
+ // Returns an error corresponding to a user cancellation event.
+ virtual WebURLError cancelledError(
+ WebFrame*, const WebURLRequest& request) { return WebURLError(); }
+
+ // Notify that a URL cannot be handled.
+ virtual void unableToImplementPolicyWithError(
+ WebFrame*, const WebURLError&) { }
+
+
+ // Navigational notifications ------------------------------------------
+
+ // A form submission has been requested, but the page's submit event handler
+ // hasn't yet had a chance to run (and possibly alter/interrupt the submit.)
+ virtual void willSendSubmitEvent(WebFrame*, const WebFormElement&) { }
+
+ // A form submission is about to occur.
+ virtual void willSubmitForm(WebFrame*, const WebFormElement&) { }
+
+ // A client-side redirect will occur. This may correspond to a <META
+ // refresh> or some script activity.
+ virtual void willPerformClientRedirect(
+ WebFrame*, const WebURL& from, const WebURL& to,
+ double interval, double fireTime) { }
+
+ // A client-side redirect was cancelled.
+ virtual void didCancelClientRedirect(WebFrame*) { }
+
+ // A client-side redirect completed.
+ virtual void didCompleteClientRedirect(WebFrame*, const WebURL& fromURL) { }
+
+ // A datasource has been created for a new navigation. The given
+ // datasource will become the provisional datasource for the frame.
+ virtual void didCreateDataSource(WebFrame*, WebDataSource*) { }
+
+ // A new provisional load has been started.
+ virtual void didStartProvisionalLoad(WebFrame*) { }
+
+ // The provisional load was redirected via a HTTP 3xx response.
+ virtual void didReceiveServerRedirectForProvisionalLoad(WebFrame*) { }
+
+ // The provisional load failed.
+ virtual void didFailProvisionalLoad(WebFrame*, const WebURLError&) { }
+
+ // Notifies the client to commit data for the given frame. The client
+ // may optionally prevent default processing by setting preventDefault
+ // to true before returning. If default processing is prevented, then
+ // it is up to the client to manually call commitDocumentData on the
+ // WebFrame. It is only valid to call commitDocumentData within a call
+ // to didReceiveDocumentData. If commitDocumentData is not called,
+ // then an empty document will be loaded.
+ virtual void didReceiveDocumentData(
+ WebFrame*, const char* data, size_t length, bool& preventDefault) { }
+
+ // The provisional datasource is now committed. The first part of the
+ // response body has been received, and the encoding of the response
+ // body is known.
+ virtual void didCommitProvisionalLoad(WebFrame*, bool isNewNavigation) { }
+
+ // The window object for the frame has been cleared of any extra
+ // properties that may have been set by script from the previously
+ // loaded document.
+ virtual void didClearWindowObject(WebFrame*) { }
+
+ // The document element has been created.
+ virtual void didCreateDocumentElement(WebFrame*) { }
+
+ // The page title is available.
+ virtual void didReceiveTitle(WebFrame*, const WebString& title) { }
+
+ // The icons for the page have changed.
+ virtual void didChangeIcons(WebFrame*) { }
+
+ // The frame's document finished loading.
+ virtual void didFinishDocumentLoad(WebFrame*) { }
+
+ // The 'load' event was dispatched.
+ virtual void didHandleOnloadEvents(WebFrame*) { }
+
+ // The frame's document or one of its subresources failed to load.
+ virtual void didFailLoad(WebFrame*, const WebURLError&) { }
+
+ // The frame's document and all of its subresources succeeded to load.
+ virtual void didFinishLoad(WebFrame*) { }
+
+ // The navigation resulted in no change to the documents within the page.
+ // For example, the navigation may have just resulted in scrolling to a
+ // named anchor or a PopState event may have been dispatched.
+ virtual void didNavigateWithinPage(WebFrame*, bool isNewNavigation) { }
+
+ // The navigation resulted in scrolling the page to a named anchor instead
+ // of downloading a new document.
+ virtual void didChangeLocationWithinPage(WebFrame*) { }
+
+ // Called upon update to scroll position, document state, and other
+ // non-navigational events related to the data held by WebHistoryItem.
+ // WARNING: This method may be called very frequently.
+ virtual void didUpdateCurrentHistoryItem(WebFrame*) { }
+
+
+ // Low-level resource notifications ------------------------------------
+
+ // An identifier was assigned to the specified request. The client
+ // should remember this association if interested in subsequent events.
+ virtual void assignIdentifierToRequest(
+ WebFrame*, unsigned identifier, const WebURLRequest&) { }
+
+ // A request is about to be sent out, and the client may modify it. Request
+ // is writable, and changes to the URL, for example, will change the request
+ // made. If this request is the result of a redirect, then redirectResponse
+ // will be non-null and contain the response that triggered the redirect.
+ virtual void willSendRequest(
+ WebFrame*, unsigned identifier, WebURLRequest&,
+ const WebURLResponse& redirectResponse) { }
+
+ // Response headers have been received for the resource request given
+ // by identifier.
+ virtual void didReceiveResponse(
+ WebFrame*, unsigned identifier, const WebURLResponse&) { }
+
+ // The resource request given by identifier succeeded.
+ virtual void didFinishResourceLoad(
+ WebFrame*, unsigned identifier) { }
+
+ // The resource request given by identifier failed.
+ virtual void didFailResourceLoad(
+ WebFrame*, unsigned identifier, const WebURLError&) { }
+
+ // The specified request was satified from WebCore's memory cache.
+ virtual void didLoadResourceFromMemoryCache(
+ WebFrame*, const WebURLRequest&, const WebURLResponse&) { }
+
+ // This frame has displayed inactive content (such as an image) from an
+ // insecure source. Inactive content cannot spread to other frames.
+ virtual void didDisplayInsecureContent(WebFrame*) { }
+
+ // The indicated security origin has run active content (such as a
+ // script) from an insecure source. Note that the insecure content can
+ // spread to other frames in the same origin.
+ virtual void didRunInsecureContent(WebFrame*, const WebSecurityOrigin&) { }
+
+
+ // Script notifications ------------------------------------------------
+
+ // Controls whether scripts are allowed to execute for this frame.
+ virtual bool allowScript(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; }
+
+ // Controls whether access to Web Databases is allowed for this frame.
+ virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) { return true; }
+
+ // Notifies the client that the frame would have executed script if script were enabled.
+ virtual void didNotAllowScript(WebFrame*) { }
+
+ // Script in the page tried to allocate too much memory.
+ virtual void didExhaustMemoryAvailableForScript(WebFrame*) { }
+
+ // Notifies that a new script context has been created for this frame.
+ // This is similar to didClearWindowObject but only called once per
+ // frame context.
+ virtual void didCreateScriptContext(WebFrame*) { }
+
+ // Notifies that this frame's script context has been destroyed.
+ virtual void didDestroyScriptContext(WebFrame*) { }
+
+ // Notifies that a garbage-collected context was created - content
+ // scripts.
+ virtual void didCreateIsolatedScriptContext(WebFrame*) { }
+
+
+ // Geometry notifications ----------------------------------------------
+
+ // The frame's document finished the initial layout of a page.
+ virtual void didFirstLayout(WebFrame*) { }
+
+ // The frame's document finished the initial non-empty layout of a page.
+ virtual void didFirstVisuallyNonEmptyLayout(WebFrame*) { }
+
+ // The size of the content area changed.
+ virtual void didChangeContentsSize(WebFrame*, const WebSize&) { }
+
+ // The main frame scrolled.
+ virtual void didChangeScrollOffset(WebFrame*) { }
+
+
+ // Find-in-page notifications ------------------------------------------
+
+ // Notifies how many matches have been found so far, for a given
+ // identifier. |finalUpdate| specifies whether this is the last update
+ // (all frames have completed scoping).
+ virtual void reportFindInPageMatchCount(
+ int identifier, int count, bool finalUpdate) { }
+
+ // Notifies what tick-mark rect is currently selected. The given
+ // identifier lets the client know which request this message belongs
+ // to, so that it can choose to ignore the message if it has moved on
+ // to other things. The selection rect is expected to have coordinates
+ // relative to the top left corner of the web page area and represent
+ // where on the screen the selection rect is currently located.
+ virtual void reportFindInPageSelection(
+ int identifier, int activeMatchOrdinal, const WebRect& selection) { }
+
+protected:
+ ~WebFrameClient() { }
+};
+
+} // namespace WebKit
+
+#endif