webkitwebframe.cpp [plain text]
#include "config.h"
#include "webkitwebframe.h"
#include "AXObjectCache.h"
#include "AnimationController.h"
#include "DOMObjectCache.h"
#include "DocumentFragment.h"
#include "DocumentLoader.h"
#include "DocumentLoaderGtk.h"
#include "FrameLoader.h"
#include "FrameLoaderClientGtk.h"
#include "FrameSelection.h"
#include "FrameTree.h"
#include "FrameView.h"
#include "GCController.h"
#include "GraphicsContext.h"
#include "GtkUtilities.h"
#include "GtkVersioning.h"
#include "HTMLFrameOwnerElement.h"
#include "JSDOMBinding.h"
#include "JSDOMWindow.h"
#include "JSElement.h"
#include "PlatformContextCairo.h"
#include "PrintContext.h"
#include "RenderListItem.h"
#include "RenderTreeAsText.h"
#include "RenderView.h"
#include "ScriptController.h"
#include "SubstituteData.h"
#include "TextIterator.h"
#include "WebKitAccessibleWrapperAtk.h"
#include "markup.h"
#include "webkit/WebKitDOMRangePrivate.h"
#include "webkitenumtypes.h"
#include "webkitglobalsprivate.h"
#include "webkitmarshal.h"
#include "webkitnetworkresponse.h"
#include "webkitnetworkrequestprivate.h"
#include "webkitnetworkresponseprivate.h"
#include "webkitsecurityoriginprivate.h"
#include "webkitwebframeprivate.h"
#include "webkitwebresource.h"
#include "webkitwebview.h"
#include "webkitwebviewprivate.h"
#include <JavaScriptCore/APICast.h>
#include <atk/atk.h>
#include <glib/gi18n-lib.h>
#include <wtf/text/CString.h>
#if ENABLE(SVG)
#include "SVGSMILElement.h"
#endif
using namespace WebKit;
using namespace WebCore;
using namespace std;
enum {
CLEARED,
LOAD_COMMITTED,
LOAD_DONE,
TITLE_CHANGED,
HOVERING_OVER_LINK,
SCROLLBARS_POLICY_CHANGED,
RESOURCE_REQUEST_STARTING,
RESOURCE_RESPONSE_RECEIVED,
RESOURCE_LOAD_FINISHED,
RESOURCE_CONTENT_LENGTH_RECEIVED,
RESOURCE_LOAD_FAILED,
INSECURE_CONTENT_RUN,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_NAME,
PROP_TITLE,
PROP_URI,
PROP_LOAD_STATUS,
PROP_HORIZONTAL_SCROLLBAR_POLICY,
PROP_VERTICAL_SCROLLBAR_POLICY
};
static guint webkit_web_frame_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE(WebKitWebFrame, webkit_web_frame, G_TYPE_OBJECT)
static void webkit_web_frame_get_property(GObject* object, guint propertyId, GValue* value, GParamSpec* paramSpec)
{
WebKitWebFrame* frame = WEBKIT_WEB_FRAME(object);
switch (propertyId) {
case PROP_NAME:
g_value_set_string(value, webkit_web_frame_get_name(frame));
break;
case PROP_TITLE:
g_value_set_string(value, webkit_web_frame_get_title(frame));
break;
case PROP_URI:
g_value_set_string(value, webkit_web_frame_get_uri(frame));
break;
case PROP_LOAD_STATUS:
g_value_set_enum(value, webkit_web_frame_get_load_status(frame));
break;
case PROP_HORIZONTAL_SCROLLBAR_POLICY:
g_value_set_enum(value, webkit_web_frame_get_horizontal_scrollbar_policy(frame));
break;
case PROP_VERTICAL_SCROLLBAR_POLICY:
g_value_set_enum(value, webkit_web_frame_get_vertical_scrollbar_policy(frame));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, paramSpec);
break;
}
}
void webkit_web_frame_core_frame_gone(WebKitWebFrame* frame)
{
ASSERT(WEBKIT_IS_WEB_FRAME(frame));
WebKitWebFramePrivate* priv = frame->priv;
if (priv->coreFrame)
DOMObjectCache::clearByFrame(priv->coreFrame);
priv->coreFrame = 0;
}
static WebKitWebDataSource* webkit_web_frame_get_data_source_from_core_loader(WebCore::DocumentLoader* loader)
{
return loader ? static_cast<WebKit::DocumentLoader*>(loader)->dataSource() : 0;
}
static void webkit_web_frame_finalize(GObject* object)
{
WebKitWebFrame* frame = WEBKIT_WEB_FRAME(object);
WebKitWebFramePrivate* priv = frame->priv;
if (priv->coreFrame) {
DOMObjectCache::clearByFrame(priv->coreFrame);
priv->coreFrame->loader()->cancelAndClear();
priv->coreFrame = 0;
}
g_free(priv->name);
g_free(priv->title);
g_free(priv->uri);
G_OBJECT_CLASS(webkit_web_frame_parent_class)->finalize(object);
}
static void webkit_web_frame_class_init(WebKitWebFrameClass* frameClass)
{
webkitInit();
webkit_web_frame_signals[CLEARED] = g_signal_new("cleared",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)G_SIGNAL_RUN_LAST,
0,
0,
0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
webkit_web_frame_signals[LOAD_COMMITTED] = g_signal_new("load-committed",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)G_SIGNAL_RUN_LAST,
0,
0,
0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
webkit_web_frame_signals[LOAD_DONE] = g_signal_new("load-done",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)G_SIGNAL_RUN_LAST,
0,
0,
0,
g_cclosure_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
webkit_web_frame_signals[TITLE_CHANGED] = g_signal_new("title-changed",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)G_SIGNAL_RUN_LAST,
0,
0,
0,
webkit_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
webkit_web_frame_signals[HOVERING_OVER_LINK] = g_signal_new("hovering-over-link",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)G_SIGNAL_RUN_LAST,
0,
0,
0,
webkit_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2,
G_TYPE_STRING, G_TYPE_STRING);
webkit_web_frame_signals[SCROLLBARS_POLICY_CHANGED] = g_signal_new("scrollbars-policy-changed",
G_TYPE_FROM_CLASS(frameClass),
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
0,
g_signal_accumulator_true_handled,
0,
webkit_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
webkit_web_frame_signals[RESOURCE_REQUEST_STARTING] = g_signal_new("resource-request-starting",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
webkit_marshal_VOID__OBJECT_OBJECT_OBJECT,
G_TYPE_NONE, 3,
WEBKIT_TYPE_WEB_RESOURCE,
WEBKIT_TYPE_NETWORK_REQUEST,
WEBKIT_TYPE_NETWORK_RESPONSE);
webkit_web_frame_signals[RESOURCE_RESPONSE_RECEIVED] = g_signal_new("resource-response-received",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
webkit_marshal_VOID__OBJECT_OBJECT,
G_TYPE_NONE, 2,
WEBKIT_TYPE_WEB_RESOURCE,
WEBKIT_TYPE_NETWORK_RESPONSE);
webkit_web_frame_signals[RESOURCE_LOAD_FINISHED] = g_signal_new("resource-load-finished",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
WEBKIT_TYPE_WEB_RESOURCE);
webkit_web_frame_signals[RESOURCE_CONTENT_LENGTH_RECEIVED] = g_signal_new("resource-content-length-received",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
webkit_marshal_VOID__OBJECT_INT,
G_TYPE_NONE, 2,
WEBKIT_TYPE_WEB_RESOURCE,
G_TYPE_INT);
webkit_web_frame_signals[RESOURCE_LOAD_FAILED] = g_signal_new("resource-load-failed",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
webkit_marshal_VOID__OBJECT_POINTER,
G_TYPE_NONE, 2,
WEBKIT_TYPE_WEB_RESOURCE,
G_TYPE_POINTER);
webkit_web_frame_signals[INSECURE_CONTENT_RUN] = g_signal_new("insecure-content-run",
G_TYPE_FROM_CLASS(frameClass),
G_SIGNAL_RUN_LAST,
0,
0, 0,
webkit_marshal_VOID__OBJECT_STRING,
G_TYPE_NONE, 2,
WEBKIT_TYPE_SECURITY_ORIGIN,
G_TYPE_STRING);
GObjectClass* objectClass = G_OBJECT_CLASS(frameClass);
objectClass->finalize = webkit_web_frame_finalize;
objectClass->get_property = webkit_web_frame_get_property;
g_object_class_install_property(objectClass, PROP_NAME,
g_param_spec_string("name",
_("Name"),
_("The name of the frame"),
0,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass, PROP_TITLE,
g_param_spec_string("title",
_("Title"),
_("The document title of the frame"),
0,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass, PROP_URI,
g_param_spec_string("uri",
_("URI"),
_("The current URI of the contents displayed by the frame"),
0,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass, PROP_LOAD_STATUS,
g_param_spec_enum("load-status",
"Load Status",
"Determines the current status of the load",
WEBKIT_TYPE_LOAD_STATUS,
WEBKIT_LOAD_FINISHED,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass, PROP_HORIZONTAL_SCROLLBAR_POLICY,
g_param_spec_enum("horizontal-scrollbar-policy",
_("Horizontal Scrollbar Policy"),
_("Determines the current policy for the horizontal scrollbar of the frame."),
GTK_TYPE_POLICY_TYPE,
GTK_POLICY_AUTOMATIC,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass, PROP_VERTICAL_SCROLLBAR_POLICY,
g_param_spec_enum("vertical-scrollbar-policy",
_("Vertical Scrollbar Policy"),
_("Determines the current policy for the vertical scrollbar of the frame."),
GTK_TYPE_POLICY_TYPE,
GTK_POLICY_AUTOMATIC,
WEBKIT_PARAM_READABLE));
g_type_class_add_private(frameClass, sizeof(WebKitWebFramePrivate));
}
static void webkit_web_frame_init(WebKitWebFrame* frame)
{
WebKitWebFramePrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(frame, WEBKIT_TYPE_WEB_FRAME, WebKitWebFramePrivate);
frame->priv = priv;
}
WebKitWebFrame* webkit_web_frame_new(WebKitWebView* webView)
{
g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
WebKitWebFrame* frame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
WebKitWebFramePrivate* priv = frame->priv;
WebKitWebViewPrivate* viewPriv = webView->priv;
priv->webView = webView;
WebKit::FrameLoaderClient* client = new WebKit::FrameLoaderClient(frame);
priv->coreFrame = Frame::create(viewPriv->corePage, 0, client).get();
priv->coreFrame->init();
priv->origin = 0;
return frame;
}
const gchar* webkit_web_frame_get_title(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
WebKitWebFramePrivate* priv = frame->priv;
return priv->title;
}
const gchar* webkit_web_frame_get_uri(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
WebKitWebFramePrivate* priv = frame->priv;
return priv->uri;
}
WebKitWebView* webkit_web_frame_get_web_view(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
WebKitWebFramePrivate* priv = frame->priv;
return priv->webView;
}
const gchar* webkit_web_frame_get_name(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
if (!coreFrame)
return "";
WebKitWebFramePrivate* priv = frame->priv;
CString frameName = coreFrame->tree()->uniqueName().string().utf8();
if (!g_strcmp0(frameName.data(), priv->name))
return priv->name;
g_free(priv->name);
priv->name = g_strdup(frameName.data());
return priv->name;
}
WebKitWebFrame* webkit_web_frame_get_parent(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
if (!coreFrame)
return 0;
return kit(coreFrame->tree()->parent());
}
void webkit_web_frame_load_uri(WebKitWebFrame* frame, const gchar* uri)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
g_return_if_fail(uri);
Frame* coreFrame = core(frame);
if (!coreFrame)
return;
coreFrame->loader()->load(ResourceRequest(KURL(KURL(), String::fromUTF8(uri))), false);
}
static void webkit_web_frame_load_data(WebKitWebFrame* frame, const gchar* content, const gchar* mimeType, const gchar* encoding, const gchar* baseURL, const gchar* unreachableURL)
{
Frame* coreFrame = core(frame);
ASSERT(coreFrame);
KURL baseKURL = baseURL ? KURL(KURL(), String::fromUTF8(baseURL)) : blankURL();
ResourceRequest request(baseKURL);
RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(content, strlen(content));
SubstituteData substituteData(sharedBuffer.release(),
mimeType ? String::fromUTF8(mimeType) : String::fromUTF8("text/html"),
encoding ? String::fromUTF8(encoding) : String::fromUTF8("UTF-8"),
KURL(KURL(), String::fromUTF8(unreachableURL)),
KURL(KURL(), String::fromUTF8(unreachableURL)));
coreFrame->loader()->load(request, substituteData, false);
}
void webkit_web_frame_load_string(WebKitWebFrame* frame, const gchar* content, const gchar* contentMimeType, const gchar* contentEncoding, const gchar* baseUri)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
g_return_if_fail(content);
webkit_web_frame_load_data(frame, content, contentMimeType, contentEncoding, baseUri, 0);
}
void webkit_web_frame_load_alternate_string(WebKitWebFrame* frame, const gchar* content, const gchar* baseURL, const gchar* unreachableURL)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
g_return_if_fail(content);
webkit_web_frame_load_data(frame, content, 0, 0, baseURL, unreachableURL);
}
void webkit_web_frame_load_request(WebKitWebFrame* frame, WebKitNetworkRequest* request)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));
Frame* coreFrame = core(frame);
if (!coreFrame)
return;
coreFrame->loader()->load(core(request), false);
}
void webkit_web_frame_stop_loading(WebKitWebFrame* frame)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
Frame* coreFrame = core(frame);
if (!coreFrame)
return;
coreFrame->loader()->stopAllLoaders();
}
void webkit_web_frame_reload(WebKitWebFrame* frame)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
Frame* coreFrame = core(frame);
if (!coreFrame)
return;
coreFrame->loader()->reload();
}
WebKitWebFrame* webkit_web_frame_find_frame(WebKitWebFrame* frame, const gchar* name)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
g_return_val_if_fail(name, 0);
Frame* coreFrame = core(frame);
if (!coreFrame)
return 0;
String nameString = String::fromUTF8(name);
return kit(coreFrame->tree()->find(AtomicString(nameString)));
}
JSGlobalContextRef webkit_web_frame_get_global_context(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
if (!coreFrame)
return 0;
return toGlobalRef(coreFrame->script()->globalObject(mainThreadNormalWorld())->globalExec());
}
WebKitWebDataSource* webkit_web_frame_get_data_source(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
return webkit_web_frame_get_data_source_from_core_loader(coreFrame->loader()->documentLoader());
}
WebKitWebDataSource* webkit_web_frame_get_provisional_data_source(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
return webkit_web_frame_get_data_source_from_core_loader(coreFrame->loader()->provisionalDocumentLoader());
}
static void begin_print_callback(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
{
PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
float width = gtk_print_context_get_width(context);
float height = gtk_print_context_get_height(context);
FloatRect printRect = FloatRect(0, 0, width, height);
printContext->begin(width);
float headerHeight = 0;
float footerHeight = 0;
float pageHeight; printContext->computePageRects(printRect, headerHeight, footerHeight, 1.0, pageHeight);
gtk_print_operation_set_n_pages(op, printContext->pageCount());
}
static void draw_page_callback(GtkPrintOperation*, GtkPrintContext* gtkPrintContext, gint pageNumber, PrintContext* corePrintContext)
{
if (pageNumber >= static_cast<gint>(corePrintContext->pageCount()))
return;
cairo_t* cr = gtk_print_context_get_cairo_context(gtkPrintContext);
float pageWidth = gtk_print_context_get_width(gtkPrintContext);
PlatformContextCairo platformContext(cr);
GraphicsContext graphicsContext(&platformContext);
corePrintContext->spoolPage(graphicsContext, pageNumber, pageWidth);
}
static void end_print_callback(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
{
PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
printContext->end();
}
GtkPrintOperationResult webkit_web_frame_print_full(WebKitWebFrame* frame, GtkPrintOperation* operation, GtkPrintOperationAction action, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), GTK_PRINT_OPERATION_RESULT_ERROR);
g_return_val_if_fail(GTK_IS_PRINT_OPERATION(operation), GTK_PRINT_OPERATION_RESULT_ERROR);
GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(frame)));
if (!widgetIsOnscreenToplevelWindow(topLevel))
topLevel = 0;
Frame* coreFrame = core(frame);
if (!coreFrame)
return GTK_PRINT_OPERATION_RESULT_ERROR;
PrintContext printContext(coreFrame);
g_signal_connect(operation, "begin-print", G_CALLBACK(begin_print_callback), &printContext);
g_signal_connect(operation, "draw-page", G_CALLBACK(draw_page_callback), &printContext);
g_signal_connect(operation, "end-print", G_CALLBACK(end_print_callback), &printContext);
return gtk_print_operation_run(operation, action, GTK_WINDOW(topLevel), error);
}
void webkit_web_frame_print(WebKitWebFrame* frame)
{
g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
WebKitWebFramePrivate* priv = frame->priv;
GtkPrintOperation* operation = gtk_print_operation_new();
GError* error = 0;
webkit_web_frame_print_full(frame, operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, &error);
g_object_unref(operation);
if (error) {
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(priv->webView));
GtkWidget* dialog = gtk_message_dialog_new(widgetIsOnscreenToplevelWindow(window) ? GTK_WINDOW(window) : 0,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", error->message);
g_error_free(error);
g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
gtk_widget_show(dialog);
}
}
gchar* webkit_web_frame_get_response_mime_type(WebKitWebFrame* frame)
{
Frame* coreFrame = core(frame);
WebCore::DocumentLoader* docLoader = coreFrame->loader()->documentLoader();
String mimeType = docLoader->responseMIMEType();
return g_strdup(mimeType.utf8().data());
}
WebKitLoadStatus webkit_web_frame_get_load_status(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), WEBKIT_LOAD_FINISHED);
WebKitWebFramePrivate* priv = frame->priv;
return priv->loadStatus;
}
GtkPolicyType webkit_web_frame_get_horizontal_scrollbar_policy(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), GTK_POLICY_AUTOMATIC);
Frame* coreFrame = core(frame);
FrameView* view = coreFrame->view();
if (!view)
return GTK_POLICY_AUTOMATIC;
ScrollbarMode hMode = view->horizontalScrollbarMode();
if (hMode == ScrollbarAlwaysOn)
return GTK_POLICY_ALWAYS;
if (hMode == ScrollbarAlwaysOff)
return GTK_POLICY_NEVER;
return GTK_POLICY_AUTOMATIC;
}
GtkPolicyType webkit_web_frame_get_vertical_scrollbar_policy(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), GTK_POLICY_AUTOMATIC);
Frame* coreFrame = core(frame);
FrameView* view = coreFrame->view();
if (!view)
return GTK_POLICY_AUTOMATIC;
ScrollbarMode vMode = view->verticalScrollbarMode();
if (vMode == ScrollbarAlwaysOn)
return GTK_POLICY_ALWAYS;
if (vMode == ScrollbarAlwaysOff)
return GTK_POLICY_NEVER;
return GTK_POLICY_AUTOMATIC;
}
WebKitSecurityOrigin* webkit_web_frame_get_security_origin(WebKitWebFrame* frame)
{
WebKitWebFramePrivate* priv = frame->priv;
if (!priv->coreFrame || !priv->coreFrame->document() || !priv->coreFrame->document()->securityOrigin())
return 0;
if (priv->origin && priv->origin->priv->coreOrigin.get() == priv->coreFrame->document()->securityOrigin())
return priv->origin;
if (priv->origin)
g_object_unref(priv->origin);
priv->origin = kit(priv->coreFrame->document()->securityOrigin());
return priv->origin;
}
WebKitNetworkResponse* webkit_web_frame_get_network_response(WebKitWebFrame* frame)
{
Frame* coreFrame = core(frame);
if (!coreFrame)
return 0;
WebCore::DocumentLoader* loader = coreFrame->loader()->activeDocumentLoader();
if (!loader)
return 0;
return kitNew(loader->response());
}
void webkit_web_frame_replace_selection(WebKitWebFrame* frame, const char* text)
{
Frame* coreFrame = core(frame);
bool selectReplacement = false;
bool smartReplace = true;
coreFrame->editor()->replaceSelectionWithText(text, selectReplacement, smartReplace);
}
WebKitDOMRange* webkit_web_frame_get_range_for_word_around_caret(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
Frame* coreFrame = core(frame);
FrameSelection* selection = coreFrame->selection();
if (selection->isNone() || selection->isRange())
return 0;
VisibleSelection visibleSelection(selection->selection().visibleStart());
visibleSelection.expandUsingGranularity(WordGranularity);
return kit(visibleSelection.firstRange().get());
}
namespace WebKit {
WebKitWebView* getViewFromFrame(WebKitWebFrame* frame)
{
WebKitWebFramePrivate* priv = frame->priv;
return priv->webView;
}
WebCore::Frame* core(WebKitWebFrame* frame)
{
if (!frame)
return 0;
WebKitWebFramePrivate* priv = frame->priv;
return priv ? priv->coreFrame : 0;
}
WebKitWebFrame* kit(WebCore::Frame* coreFrame)
{
if (!coreFrame)
return 0;
ASSERT(coreFrame->loader());
WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(coreFrame->loader()->client());
return client ? client->webFrame() : 0;
}
}