String BlobURL::getOrigin(const KURL& url) {
ASSERT(url.protocolIs(kBlobProtocol));
unsigned startIndex = url.pathStart();
unsigned endIndex = url.pathAfterLastSlash();
return url.getString().substring(startIndex, endIndex - startIndex - 1);
}
static ALWAYS_INLINE void visitedURLInline(const KURL& base, const AtomicString& attributeURL, Vector<UChar, 512>& buffer)
{
if (attributeURL.isNull())
return;
const UChar* characters = attributeURL.characters();
unsigned length = attributeURL.length();
// This is a poor man's completeURL. Faster with less memory allocation.
// FIXME: It's missing a lot of what completeURL does and a lot of what KURL does.
// For example, it does not handle international domain names properly.
// FIXME: It is wrong that we do not do further processing on strings that have "://" in them:
// 1) The "://" could be in the query or anchor.
// 2) The URL's path could have a "/./" or a "/../" or a "//" sequence in it.
// FIXME: needsTrailingSlash does not properly return true for a URL that has no path, but does
// have a query or anchor.
bool hasColonSlashSlash = containsColonSlashSlash(characters, length);
if (hasColonSlashSlash && !needsTrailingSlash(characters, length)) {
buffer.append(attributeURL.characters(), attributeURL.length());
return;
}
if (hasColonSlashSlash) {
// FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
// end of the path, *before* the query or anchor.
buffer.append(characters, length);
buffer.append('/');
return;
}
if (!length)
buffer.append(base.string().characters(), base.string().length());
else {
switch (characters[0]) {
case '/':
buffer.append(base.string().characters(), base.pathStart());
break;
case '#':
buffer.append(base.string().characters(), base.pathEnd());
break;
default:
buffer.append(base.string().characters(), base.pathAfterLastSlash());
break;
}
}
buffer.append(characters, length);
cleanPath(buffer);
if (needsTrailingSlash(buffer.data(), buffer.size())) {
// FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
// end of the path, *before* the query or anchor.
buffer.append('/');
}
return;
}
static PathToDefaultProtectionSpaceMap::iterator findDefaultProtectionSpaceForURL(const KURL& url)
{
ASSERT(url.protocolIsInHTTPFamily());
ASSERT(url.isValid());
PathToDefaultProtectionSpaceMap& map = pathToDefaultProtectionSpaceMap();
// Don't spend time iterating the path for origins that don't have any credentials.
if (!originsWithCredentials().contains(originStringFromURL(url)))
return map.end();
String directoryURL = protectionSpaceMapKeyFromURL(url);
unsigned directoryURLPathStart = url.pathStart();
while (true) {
PathToDefaultProtectionSpaceMap::iterator iter = map.find(directoryURL);
if (iter != map.end())
return iter;
if (directoryURL.length() == directoryURLPathStart + 1) // path is "/" already, cannot shorten it any more
return map.end();
size_t index = directoryURL.reverseFind('/', directoryURL.length() - 2);
ASSERT(index != notFound);
directoryURL = directoryURL.substring(0, (index == directoryURLPathStart) ? index + 1 : index);
ASSERT(directoryURL.length() > directoryURLPathStart);
ASSERT(directoryURL.length() == directoryURLPathStart + 1 || directoryURL[directoryURL.length() - 1] != '/');
}
}
String DOMURLUtilsReadOnly::host(const KURL& kurl) {
if (kurl.hostEnd() == kurl.pathStart())
return kurl.host();
if (isDefaultPortForProtocol(kurl.port(), kurl.protocol()))
return kurl.host();
return kurl.host() + ":" + String::number(kurl.port());
}
static String protectionSpaceMapKeyFromURL(const KURL& url)
{
ASSERT(url.isValid());
// Remove the last path component that is not a directory to determine the subtree for which credentials will apply.
// We keep a leading slash, but remove a trailing one.
String directoryURL = url.string().substring(0, url.pathEnd());
unsigned directoryURLPathStart = url.pathStart();
ASSERT(directoryURL[directoryURLPathStart] == '/');
if (directoryURL.length() > directoryURLPathStart + 1) {
size_t index = directoryURL.reverseFind('/');
ASSERT(index != notFound);
directoryURL = directoryURL.substring(0, (index != directoryURLPathStart) ? index : directoryURLPathStart + 1);
}
return directoryURL;
}
KURL History::urlForState(const String& urlString)
{
KURL baseURL = m_frame->loader()->baseURL();
if (urlString.isEmpty())
return baseURL;
#if 1
// modified at webkit.org trunk r64077
return KURL(baseURL, urlString);
#else
KURL absoluteURL(baseURL, urlString);
if (!absoluteURL.isValid())
return KURL();
if (absoluteURL.string().left(absoluteURL.pathStart()) != baseURL.string().left(baseURL.pathStart()))
return KURL();
return absoluteURL;
#endif
}