/* static */ OP_STATUS
DOM_LSInput::GetSystemId(const uni_char *&systemId, ES_Object *input, DOM_EnvironmentImpl *environment)
{
OP_BOOLEAN result;
ES_Value value;
systemId = NULL;
const uni_char *stringData;
RETURN_IF_ERROR(GetStringData(stringData, input, environment));
if (stringData)
return OpStatus::OK;
RETURN_IF_ERROR(result = environment->GetDOMRuntime()->GetName(input, UNI_L("systemId"), &value));
if (result == OpBoolean::IS_TRUE && value.type == VALUE_STRING && *value.value.string)
{
TempBuffer *buffer = environment->GetWindow()->GetEmptyTempBuf();
RETURN_IF_ERROR(buffer->Append(value.value.string));
systemId = buffer->GetStorage();
}
return OpStatus::OK;
}
/* static */ BOOL
ES_DebugBuiltins::getObjectDemographics(ES_Execution_Context *context, unsigned argc, ES_Value_Internal *argv, ES_Value_Internal *return_value)
{
return_value->SetNull();
if (argc == 1)
{
if (!argv[0].ToNumber(context) || !argv[0].IsUInt32())
return FALSE;
if (ES_Heap *heap = g_ecmaManager->GetHeapById(argv[0].GetNumAsUInt32()))
{
TempBuffer *buffer = g_ecmaManager->GetHeapDebuggerBuffer();
buffer->Clear();
buffer->Append("{ ");
unsigned *live_objects = heap->live_objects;
for (unsigned index = 0; index < GCTAG_UNINITIALIZED; ++index)
{
if (index != 0)
buffer->Append(", ");
buffer->Append("\"");
buffer->Append(g_ecmaClassName[index]);
buffer->Append("\": ");
buffer->AppendUnsignedLong(live_objects[index]);
}
buffer->Append(" }");
return_value->SetString(JString::Make(context, buffer->GetStorage(), buffer->Length()));
}
}
return TRUE;
}
/* virtual */
ES_GetState DOM_JILRadioInfo::InternalGetName(OpAtom property_atom, ES_Value* value, DOM_Runtime* origining_runtime, ES_Value* restart_value)
{
switch (property_atom)
{
case OP_ATOM_isRadioEnabled:
{
if (value)
{
OP_BOOLEAN is_radio_enabled = g_op_telephony_network_info->IsRadioEnabled();
if (!OpStatus::IsError(is_radio_enabled))
DOMSetBoolean(value, is_radio_enabled == OpBoolean::IS_TRUE);
else if (is_radio_enabled == OpStatus::ERR_NOT_SUPPORTED)
DOMSetUndefined(value);
else
return ConvertCallToGetName(HandleJILError(is_radio_enabled, value, origining_runtime), value);
}
return GET_SUCCESS;
}
case OP_ATOM_isRoaming:
{
if (value)
{
OP_BOOLEAN is_roaming = g_op_telephony_network_info->IsRoaming();
if (!OpStatus::IsError(is_roaming))
DOMSetBoolean(value, is_roaming == OpBoolean::IS_TRUE);
else if (is_roaming == OpStatus::ERR_NOT_SUPPORTED)
DOMSetUndefined(value);
else
return ConvertCallToGetName(HandleJILError(is_roaming, value, origining_runtime), value);
}
return GET_SUCCESS;
}
case OP_ATOM_radioSignalSource:
{
if (value)
{
OpTelephonyNetworkInfo::RadioSignalSource radio_source;
OP_STATUS ret_val = g_op_telephony_network_info->GetRadioSignalSource(&radio_source);
if (!OpStatus::IsError(ret_val))
{
TempBuffer* buffer = GetEmptyTempBuf();
ret_val = buffer->Append(RadioSignalSourceValueToString(radio_source));
if (OpStatus::IsSuccess(ret_val))
DOMSetString(value, buffer);
}
else if (ret_val == OpStatus::ERR_NOT_SUPPORTED)
DOMSetUndefined(value);
if (OpStatus::IsError(ret_val))
return ConvertCallToGetName(HandleJILError(ret_val, value, origining_runtime), value);
}
return GET_SUCCESS;
}
case OP_ATOM_radioSignalStrengthPercent:
{
if (value)
{
double signal_strength;
OP_STATUS ret_val = g_op_telephony_network_info->GetRadioSignalStrength(&signal_strength);
if (!OpStatus::IsError(ret_val))
DOMSetNumber(value, signal_strength);
else if (ret_val == OpStatus::ERR_NOT_SUPPORTED)
DOMSetUndefined(value);
else
return ConvertCallToGetName(HandleJILError(ret_val, value, origining_runtime), value);
}
return GET_SUCCESS;
}
case OP_ATOM_onSignalSourceChange:
DOMSetObject(value, m_on_radio_source_changed);
return GET_SUCCESS;
}
return GET_FAILED;
}
/* static */ OP_STATUS
JS_Console::FormatString(ES_Value* argv, int argc, OpString &str)
{
if (argc == 0)
return OpStatus::OK;
// Holds the formatted string.
TempBuffer buf;
// The argument which will be stringified next.
int argument = 0;
// If the first argument is a string, check if it contains placeholders.
if (argv[0].type == VALUE_STRING)
{
// The first argument is the format string. It may or may not contain
// formatting placeholders (%).
const uni_char *placeholder = argv[0].value.string;
const uni_char *stored = placeholder;
// Skip the formatting string.
++argument;
while ((placeholder = uni_strchr(placeholder, '%')) != NULL)
{
// Calculate the length until the '%'.
int length = (placeholder - stored);
// Skip the '%', and check that 'placeholder' now points to
// a supported character.
if (!JS_Console::IsSupportedPlaceholder(++placeholder))
continue;
// Append everything up until the '%'.
if (length > 0)
RETURN_IF_ERROR(buf.Append(stored, length));
// If the character after the first '%' is another '%', then output
// a single '%'.
if (*placeholder == '%')
RETURN_IF_ERROR(buf.Append("%"));
// Otherwise, append the string representation of the ES_Value.
else if (argument < argc)
RETURN_IF_ERROR(JS_Console::AppendValue(argv[argument++], buf));
// Or, if we don't have more arguments, output the original placeholder.
else
RETURN_IF_ERROR(buf.Append(placeholder - 1, 2));
// Skip the character following the %, but only if not at the
// end of string.
if (*placeholder != '\0')
++placeholder;
stored = placeholder;
}
// Append the rest of the formatting string, if any.
if (*stored != '\0')
RETURN_IF_ERROR(buf.Append(stored));
}
// If we have more arguments, append them in a space delimited list.
while (argument < argc)
{
// Never start a string with a space.
if (argument > 0)
RETURN_IF_ERROR(buf.Append(" "));
RETURN_IF_ERROR(AppendValue(argv[argument++], buf));
}
return str.Set(buf.GetStorage());
}
/* static */ BOOL
ES_DebugBuiltins::getHeapInformation(ES_Execution_Context *context, unsigned argc, ES_Value_Internal *argv, ES_Value_Internal *return_value)
{
Head *active, *inactive, *destroy;
g_ecmaManager->GetHeapLists(active, inactive, destroy);
TempBuffer *buffer = g_ecmaManager->GetHeapDebuggerBuffer();
buffer->Clear();
buffer->Append("{ \"heaps\": { ");
ES_Heap *heads[3] = { static_cast<ES_Heap *>(active->First()), static_cast<ES_Heap *>(inactive->First()), static_cast<ES_Heap *>(destroy->First()) };
for (unsigned head = 0; head < 3; ++head)
for (ES_Heap *heap = heads[head]; heap; heap = static_cast<ES_Heap *>(heap->Suc()))
{
buffer->AppendFormat(UNI_L("\"%u\": { \"bytesLive\": %u, \"bytesLivePeak\": %u, \"bytesLimit\": %u, \"runtimes\": ["), heap->Id(), heap->GetBytesLive(), heap->GetBytesLivePeak(), heap->GetBytesLimit());
ES_Runtime *runtime = heap->GetFirstRuntime();
while (runtime)
{
#ifndef _STANDALONE
ES_Object *global_object = runtime->GetGlobalObject();
if (global_object->IsHostObject() && ES_Runtime::GetHostObject(global_object)->IsA(DOM_TYPE_WINDOW))
{
OpString url;
DOM_Utils::GetOriginURL(DOM_Utils::GetDOM_Runtime(runtime)).GetAttribute(URL::KUniName, url);
for (unsigned index = 0; index < static_cast<unsigned>(url.Length()); ++index)
if (url.CStr()[index] == '"')
url.Insert(index++, "\\");
buffer->AppendFormat(UNI_L("\"%s\""), url.CStr());
}
else
#endif // _STANDALONE
buffer->Append("\"<unidentified runtime>\"");
runtime = g_ecmaManager->GetNextRuntimePerHeap(runtime);
if (runtime)
buffer->Append(", ");
}
buffer->Append("] }, ");
}
buffer->AppendFormat(UNI_L("\"count\": %u }, \"allocators\": ["), active->Cardinal() + inactive->Cardinal() + destroy->Cardinal());
for (ES_PageAllocator *allocator = static_cast<ES_PageAllocator *>(g_ecmaPageAllocatorList->First()); allocator; allocator = static_cast<ES_PageAllocator *>(allocator->Suc()))
{
buffer->AppendFormat(UNI_L("{ \"chunks\": %u, \"chunkSize\": %u, \"pages\": %u, \"pageSize\": %u, \"heaps\": ["), allocator->CountChunks(), allocator->ChunkSize(), allocator->CountPages(), allocator->PageSize());
for (ES_HeapHandle *heaph = allocator->GetFirstHeapHandle(); heaph; heaph = static_cast<ES_HeapHandle *>(heaph->Suc()))
{
buffer->AppendUnsignedLong(heaph->heap->Id());
if (heaph->Suc())
buffer->Append(", ");
}
buffer->Append("] }");
if (allocator->Suc())
buffer->Append(", ");
}
buffer->Append("], \"cachedPrograms\": [");
for (Link *link = RT_DATA.program_cache->GetCachedPrograms()->First(); link; link = link->Suc())
{
ES_ProgramCodeStatic *program = static_cast<ES_ProgramCodeStatic *>(link);
buffer->AppendFormat(UNI_L("{ \"url\": \"\", \"length\": %u }"), program->source.GetSource()->length);
if (link->Suc())
buffer->Append(", ");
}
buffer->Append("] }");
return_value->SetString(JString::Make(context, buffer->GetStorage(), buffer->Length()));
return TRUE;
}
ES_GetState
DOM_BrowserTab::GetTabInfo(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime, ES_Object* restart_object)
{
if (!value)
return GET_SUCCESS;
// Private mode can be obtained synchronously if we have window.
if (property_name == OP_ATOM_private)
{
Window* window = GetTabWindow();
if (window)
{
DOMSetBoolean(value, window->GetPrivacyMode());
return GET_SUCCESS;
}
}
OP_ASSERT(GetTabId());
DOM_TabsApiHelper* call_helper;
if (!restart_object)
{
GET_FAILED_IF_ERROR(DOM_TabsApiHelper::Make(call_helper, static_cast<DOM_Runtime*>(origining_runtime)));
call_helper->QueryTab(GetTabId());
}
else
call_helper = DOM_HOSTOBJECT(restart_object, DOM_TabsApiHelper);
if (call_helper->IsFinished())
{
if (property_name == OP_ATOM_closed)
{
DOMSetBoolean(value, OpStatus::IsError(call_helper->GetStatus()));
return GET_SUCCESS;
}
else
GET_FAILED_IF_ERROR(call_helper->GetStatus());
switch (property_name)
{
case OP_ATOM_browserWindow:
DOM_BrowserWindow* new_win;
GET_FAILED_IF_ERROR(DOM_TabApiCache::GetOrCreateWindow(new_win, m_extension_support, call_helper->GetResult().value.query_tab.browser_window_id, GetRuntime()));
DOMSetObject(value, new_win);
break;
case OP_ATOM_locked:
DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_locked);
break;
case OP_ATOM_position:
DOMSetNumber(value, call_helper->GetResult().value.query_tab.position);
break;
case OP_ATOM_tabGroup:
if (call_helper->GetResult().value.query_tab.tab_group_id == 0)
DOMSetNull(value);
else
{
DOM_BrowserTabGroup* tab_group;
GET_FAILED_IF_ERROR(DOM_TabApiCache::GetOrCreateTabGroup(tab_group, m_extension_support, call_helper->GetResult().value.query_tab.tab_group_id, GetRuntime()));
DOMSetObject(value, tab_group);
}
break;
case OP_ATOM_focused:
case OP_ATOM_selected:
DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_selected);
break;
case OP_ATOM_title:
if (!call_helper->GetResult().value.query_tab.is_private || IsPrivateDataAllowed())
{
TempBuffer* tmp = GetEmptyTempBuf();
GET_FAILED_IF_ERROR(tmp->Append(call_helper->GetResult().value.query_tab.title));
DOMSetString(value, tmp);
}
return GET_SUCCESS;
case OP_ATOM_private:
DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_private);
return GET_SUCCESS;
default:
OP_ASSERT(!"Unexpected property");
}
return GET_SUCCESS;
}
else
return call_helper->BlockGet(value, origining_runtime);
}
/* virtual */ ES_PutState
JS_Location::PutName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime)
{
if (GetName(property_name, NULL, origining_runtime) != GET_SUCCESS)
return PUT_FAILED;
FramesDocument *frames_doc = GetFramesDocument();
if (!frames_doc)
return PUT_SUCCESS;
if (value->type != VALUE_STRING)
return PUT_NEEDS_STRING;
const uni_char *value_string = value->value.string;
while (value_string[0] == ' ')
++value_string;
if (property_name == OP_ATOM_href)
if (value_string[0] == '#')
property_name = OP_ATOM_hash;
else if (value_string[0] == '?')
property_name = OP_ATOM_search;
URL url;
DocumentReferrer ref_url(GetStandardRefURL(frames_doc, origining_runtime));
TempBuffer buffer;
URL current_url = ref_url.url;
#ifdef SELFTEST
if (!do_navigation)
current_url = this->current_url;
#endif // SELFTEST
switch (property_name)
{
case OP_ATOM_href:
case OP_ATOM_protocol:
case OP_ATOM_host:
case OP_ATOM_hostname:
case OP_ATOM_port:
case OP_ATOM_pathname:
BOOL allowed;
if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::DOM_ALLOWED_TO_NAVIGATE, static_cast<DOM_Runtime *>(origining_runtime), GetRuntime(), allowed)) ||
!allowed)
return PUT_SECURITY_VIOLATION;
}
switch (property_name)
{
case OP_ATOM_protocol:
{
unsigned length = uni_strlen(value_string);
while (length > 0 && value_string[length - 1] == ':')
length--;
if (length > 0)
{
const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');
if (!current_scheme_end)
return PUT_SUCCESS;
PUT_FAILED_IF_ERROR(buffer.Append(value_string, length));
PUT_FAILED_IF_ERROR(buffer.Append(current_scheme_end));
url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());
BOOL allowed;
if (url.Type() == URL_JAVASCRIPT)
if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::DOM_STANDARD, static_cast<DOM_Runtime *>(origining_runtime), GetRuntime(), allowed)) ||
!allowed)
return PUT_SUCCESS;
}
break;
}
case OP_ATOM_host:
{
const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');
// URL must be an "authority-based URL"
if (current_scheme_end && current_scheme_end[1] == '/' && current_scheme_end[2] == '/')
{
OpString hostname;
PUT_FAILED_IF_ERROR(current_url.GetAttribute(URL::KUniHostName, hostname));
/* Just bail if the URL doesn't have a hostname after all. */
if (!hostname.CStr())
return PUT_SUCCESS;
uni_char *hostname_start = uni_strstr(current_url_string, hostname.CStr());
OP_ASSERT(hostname_start);
uni_char *hostname_end = hostname_start + hostname.Length();
unsigned short port = current_url.GetAttribute(URL::KServerPort);
if (port > 0 && *hostname_end == ':')
{
hostname_end++;
while (uni_isdigit(*hostname_end))
hostname_end++;
}
PUT_FAILED_IF_ERROR(buffer.Append(current_url_string, hostname_start - current_url_string));
PUT_FAILED_IF_ERROR(buffer.Append(value_string));
PUT_FAILED_IF_ERROR(buffer.Append(hostname_end));
url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());
}
break;
}
case OP_ATOM_hostname:
{
while (*value_string == '/')
value_string++;
const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');
// URL must be an "authority-based URL"
if (*value_string && current_scheme_end && current_scheme_end[1] == '/' && current_scheme_end[2] == '/')
{
OpString hostname;
PUT_FAILED_IF_ERROR(current_url.GetAttribute(URL::KUniHostName, hostname));
/* Just bail if the URL doesn't have a hostname after all. */
if (!hostname.CStr())
return PUT_SUCCESS;
uni_char *hostname_start = uni_strstr(current_url_string, hostname.CStr());
OP_ASSERT(hostname_start);
uni_char *hostname_end = hostname_start + hostname.Length();
PUT_FAILED_IF_ERROR(buffer.Append(current_url_string, hostname_start - current_url_string));
PUT_FAILED_IF_ERROR(buffer.Append(value_string));
PUT_FAILED_IF_ERROR(buffer.Append(hostname_end));
url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());
}
break;
}
case OP_ATOM_port:
{
const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');
// URL must be an "authority-based URL"
if (current_scheme_end && current_scheme_end[1] == '/' && current_scheme_end[2] == '/')
{
while (*value_string == '0')
value_string++;
int port = 0;
if (uni_isdigit(*value_string))
port = uni_atoi(value_string);
if (port <= 0 || port > 65535)
break;
OpString hostname;
PUT_FAILED_IF_ERROR(current_url.GetAttribute(URL::KUniHostName, hostname));
/* Just bail if the URL doesn't have a hostname after all. */
if (!hostname.CStr())
return PUT_SUCCESS;
uni_char *hostname_start = uni_strstr(current_scheme_end, hostname.CStr());
OP_ASSERT(hostname_start);
uni_char *hostname_end = hostname_start + hostname.Length();
PUT_FAILED_IF_ERROR(buffer.Append(current_url_string, hostname_end - current_url_string));
PUT_FAILED_IF_ERROR(buffer.Append(":"));
if (*hostname_end == ':')
{
hostname_end++;
while (uni_isdigit(*hostname_end))
hostname_end++;
}
PUT_FAILED_IF_ERROR(buffer.AppendLong(port));
PUT_FAILED_IF_ERROR(buffer.Append(hostname_end));
url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());
}
break;
}
case OP_ATOM_href:
case OP_ATOM_pathname:
{
url = GetEncodedURL(origining_runtime->GetFramesDocument(), value_string);
BOOL allowed;
// Stricter security for javascript urls. It's possible this check should move into DocumentManager in the future.
if (url.Type() == URL_JAVASCRIPT)
if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::DOM_STANDARD, static_cast<DOM_Runtime *>(origining_runtime), GetRuntime(), allowed)) ||
!allowed)
return PUT_SUCCESS;
break;
}
case OP_ATOM_search:
{
const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
int current_len;
const uni_char *current_search_start = uni_strchr(current_url_string, '?');
if (current_search_start)
current_len = current_search_start - current_url_string;
else
current_len = uni_strlen(current_url_string);
if (value_string[0] == '?')
++value_string;
PUT_FAILED_IF_ERROR(buffer.Expand(current_len + uni_strlen(value_string) + 2));
OpStatus::Ignore(buffer.Append(current_url_string, current_len)); // buffer is successfully expanded above
OpStatus::Ignore(buffer.Append("?"));
OpStatus::Ignore(buffer.Append(value_string));
url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());
break;
}
case OP_ATOM_hash:
if (value_string[0] == '#')
++value_string;
// Strip trailing whitespace
if (unsigned length = uni_strlen(value_string))
{
if (value_string[length - 1] == ' ')
{
PUT_FAILED_IF_ERROR(buffer.Append(value_string));
uni_char *string = buffer.GetStorage();
while (length > 0 && string[length - 1] == ' ')
--length;
string[length] = 0;
value_string = string;
}
}
#ifdef SELFTEST
url = URL(!do_navigation ? current_url : frames_doc->GetURL(), value_string);
#else
url = URL(frames_doc->GetURL(), value_string);
#endif // SELFTEST
break;
}
if (url.Type() != URL_NULL_TYPE)
{
#ifdef GADGET_SUPPORT
switch (property_name)
{
case OP_ATOM_href:
case OP_ATOM_protocol:
case OP_ATOM_host:
case OP_ATOM_hostname:
case OP_ATOM_port:
case OP_ATOM_pathname:
{
BOOL allowed;
if (frames_doc->GetWindow()->GetGadget())
if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::GADGET_ALLOWED_TO_NAVIGATE, OpSecurityContext(frames_doc), url, allowed)) || !allowed)
return PUT_SECURITY_VIOLATION;
}
}
#endif // GADGET_SUPPORT
return SetTheURL(frames_doc, ref_url, url, GetCurrentThread(origining_runtime), property_name == OP_ATOM_hash);
}
else
return PUT_SUCCESS;
}
/* virtual */ ES_GetState
JS_Location::GetName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime)
{
TempBuffer *buffer = GetEmptyTempBuf();
URL url;
if (fakewindow)
url = fakewindow->GetURL();
#ifdef SELFTEST
else if (!do_navigation)
url = current_url;
#endif // SELFTEST
else if (FramesDocument *frames_doc = GetFramesDocument())
{
url = frames_doc->GetURL();
// The anchors (hash) might be better in DocumentManager
URL doc_man_url = frames_doc->GetDocManager()->GetCurrentURL();
if (doc_man_url == url) // Doesn't compare anchors
url = doc_man_url;
}
#ifdef DOM_WEBWORKERS_SUPPORT
/* No FramesDocument to query, so consult the origin DocumentManager for the Worker */
if (!GetFramesDocument())
{
DOM_WebWorkerController *web_workers = GetEnvironment()->GetWorkerController();
if (DOM_WebWorker *ww = web_workers->GetWorkerObject())
url = ww->GetLocationURL();
else if (DocumentManager *doc = web_workers->GetWorkerDocManager())
url = doc->GetCurrentURL();
OP_ASSERT(!url.IsEmpty());
}
#endif // DOM_WEBWORKERS_SUPPORT
switch (property_name)
{
case OP_ATOM_href:
DOMSetString(value, url.GetAttribute(URL::KUniName_With_Fragment_Escaped).CStr());
return GET_SUCCESS;
case OP_ATOM_protocol:
if (value)
{
const char *protocol = url.GetAttribute(URL::KProtocolName).CStr();
if (protocol)
{
GET_FAILED_IF_ERROR(buffer->Append(protocol));
GET_FAILED_IF_ERROR(buffer->Append(":"));
}
DOMSetString(value, buffer);
}
return GET_SUCCESS;
case OP_ATOM_host:
case OP_ATOM_hostname:
if (value)
{
const uni_char *name = url.GetServerName() ? url.GetServerName()->UniName() : NULL;
if (property_name == OP_ATOM_host)
{
unsigned short port = url.GetServerPort();
if (port)
{
GET_FAILED_IF_ERROR(buffer->Append(name));
GET_FAILED_IF_ERROR(buffer->Append(":"));
GET_FAILED_IF_ERROR(buffer->AppendUnsignedLong(port));
name = buffer->GetStorage();
}
}
DOMSetString(value, name);
}
return GET_SUCCESS;
case OP_ATOM_port:
if (value)
{
unsigned short port = url.GetServerPort();
if (port)
GET_FAILED_IF_ERROR(buffer->AppendUnsignedLong(port));
DOMSetString(value, buffer);
}
return GET_SUCCESS;
case OP_ATOM_pathname:
if (value)
{
const uni_char *path = url.GetAttribute(URL::KUniPath).CStr();
if (path)
{
GET_FAILED_IF_ERROR(buffer->Append(path));
uni_char *path_tmp = buffer->GetStorage();
/* It isn't obvious from the JS spec and the relevant RFC, but in
Javascript the 'pathname' excludes any arguments passed to the page. */
if (uni_char *query_start = uni_strchr(path_tmp, '?'))
{
path = path_tmp;
*query_start = 0;
}
}
DOMSetString(value, path);
}
return GET_SUCCESS;
case OP_ATOM_search:
if (value)
{
const uni_char *name = url.GetAttribute(URL::KUniName).CStr();
if (name)
name = uni_strchr(name, '?');
DOMSetString(value, name);
}
return GET_SUCCESS;
case OP_ATOM_hash:
if (value)
{
const uni_char *fragment = url.UniRelName();
// MSIE emits "#" for the empty fragment (as in http://www.opera.com/# ) but no other
// browser does that and neither will we.
if (fragment && *fragment)
{
GET_FAILED_IF_ERROR(buffer->Append('#'));
GET_FAILED_IF_ERROR(buffer->Append(fragment));
fragment = buffer->GetStorage();
}
DOMSetString(value, fragment);
}
return GET_SUCCESS;
}
return GET_FAILED;
}
/* virtual */ OP_STATUS
DOM_XSLTStringDataCollector::CollectStringData(const uni_char *string, unsigned string_length)
{
return resulting_text.Append(string, string_length);
}