void PlatformContextSkiaJava::applyAntiAliasedClipPaths(WTF::Vector<SkPath>& paths)
{
// Anti-aliased clipping:
//
// Skia's clipping is 1-bit only. Consider what would happen if it were 8-bit:
// We have a square canvas, filled with white and we declare a circular
// clipping path. Then we fill twice with a black rectangle. The fractional
// pixels would first get the correct color (white * alpha + black * (1 -
// alpha)), but the second fill would apply the alpha to the already
// modified color and the result would be too dark.
//
// This, anti-aliased clipping needs to be performed after the drawing has
// been done. In order to do this, we create a new layer of the canvas in
// clipPathAntiAliased and store the clipping path. All drawing is done to
// the layer's bitmap while it's in effect. When WebKit calls restore() to
// undo the clipping, this function is called.
//
// Here, we walk the list of clipping paths backwards and, for each, we
// clear outside of the clipping path. We only need a single extra layer
// for any number of clipping paths.
//
// When we call restore on the SkCanvas, the layer's bitmap is composed
// into the layer below and we end up with correct, anti-aliased clipping.
SkPaint paint;
paint.setXfermodeMode(SkXfermode::kClear_Mode);
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kFill_Style);
for (size_t i = paths.size() - 1; i < paths.size(); --i) {
paths[i].setFillType(SkPath::kInverseWinding_FillType);
m_canvas->drawPath(paths[i], paint);
}
m_canvas->restore();
}
void EditorClientImpl::checkTextOfParagraph(const UChar* text, int length,
TextCheckingTypeMask mask,
WTF::Vector<TextCheckingResult>& results)
{
if (!m_webView->spellCheckClient())
return;
WebTextCheckingTypeMask webMask = static_cast<WebTextCheckingTypeMask>(mask);
WebVector<WebTextCheckingResult> webResults;
m_webView->spellCheckClient()->checkTextOfParagraph(WebString(text, length), webMask, &webResults);
results.resize(webResults.size());
for (size_t i = 0; i < webResults.size(); ++i)
results[i] = webResults[i];
}
EncodedJSValue JSC_HOST_CALL COMMethodCall::call(ExecState* execState) {
COMMethodCall* callee = jsCast<COMMethodCall*>(execState->callee());
if (execState->argumentCount() != callee->_parameterCells.size()) {
// TODO: error
CRASH();
}
COMInterop* interop = jsCast<GlobalObject*>(execState->lexicalGlobalObject())->interop();
size_t numberOfABIParameters = callee->_parameterCells.size() + (callee->_isVoid ? 1 : 2);
HRESULT hr;
Microsoft::WRL::ComPtr<IUnknown> self;
hr = interop->wrap(execState->thisValue(), callee->_methodInterface, self.GetAddressOf());
void** vtable = *reinterpret_cast<void***>(self.Get());
void* fn = vtable[callee->_methodIndex];
WTF::Vector<void*> arguments;
arguments.reserveCapacity(numberOfABIParameters);
IUnknown* thisValue = self.Get();
arguments.append(&thisValue);
for (int i = 0; i < callee->_parameterCells.size(); i++) {
JSCell* type = callee->_parameterCells[i].get();
void* buffer = _alloca(std::max(sizeof(ffi_arg), callee->_parameterTypes[i + 1]->size));
getFFIMethodTable(type)->marshalJSToNative(type, execState, execState->uncheckedArgument(i), buffer);
arguments.append(buffer);
}
void* returnBuffer = nullptr;
if (!callee->_isVoid) {
returnBuffer = _alloca(std::max(sizeof(ffi_arg), callee->_parameterTypes[numberOfABIParameters - 1]->size));
arguments.append(&returnBuffer);
}
ffi_call(&callee->_cif, FFI_FN(fn), &hr, arguments.data());
JSValue jsResult;
if (!SUCCEEDED(hr)) {
_com_error error(hr, nullptr);
jsResult = execState->vm().throwException(execState, createError(execState, error.ErrorMessage()));
} else if (!callee->_isVoid) {
JSCell* returnType = callee->_returnType.get();
jsResult = getFFIMethodTable(returnType)->marshalNativeToJS(returnType, execState, returnBuffer);
} else {
jsResult = jsUndefined();
}
return JSValue::encode(jsResult);
}
void TilesManager::discardTexturesVector(unsigned long long sparedDrawCount,
WTF::Vector<TileTexture*>& textures,
bool deallocateGLTextures)
{
const unsigned int max = textures.size();
int dealloc = 0;
WTF::Vector<int> discardedIndex;
for (unsigned int i = 0; i < max; i++) {
TextureOwner* owner = textures[i]->owner();
if (!owner || owner->drawCount() < sparedDrawCount) {
if (deallocateGLTextures) {
// deallocate textures' gl memory
textures[i]->discardGLTexture();
discardedIndex.append(i);
} else if (owner) {
// simply detach textures from owner
static_cast<Tile*>(owner)->discardTextures();
}
dealloc++;
}
}
bool base = textures == m_textures;
// Clean up the vector of TileTextures and reset the max texture count.
if (discardedIndex.size()) {
android::Mutex::Autolock lock(m_texturesLock);
for (int i = discardedIndex.size() - 1; i >= 0; i--)
textures.remove(discardedIndex[i]);
int remainedTextureNumber = textures.size();
int* countPtr = base ? &m_currentTextureCount : &m_currentLayerTextureCount;
if (remainedTextureNumber < *countPtr) {
ALOGV("reset currentTextureCount for %s tiles from %d to %d",
base ? "base" : "layer", *countPtr, remainedTextureNumber);
*countPtr = remainedTextureNumber;
}
}
ALOGV("Discarded %d %s textures (out of %d %s tiles)",
dealloc, (deallocateGLTextures ? "gl" : ""),
max, base ? "base" : "layer");
}
void FrameLoaderClientAndroid::dispatchDidFailProvisionalLoad(const ResourceError& error) {
ASSERT(m_frame);
// Ignore ErrorInterrupted since it is due to a policy interruption. This
// is caused by a decision to download the main resource rather than
// display it.
if (error.errorCode() == InternalErrorInterrupted
|| error.errorCode() == InternalErrorCancelled) {
// If we decided to download the main resource or if the user cancelled
// it, make sure we report that the load is done.
didFinishLoad();
return;
}
AssetManager* am = globalAssetManager();
// Check to see if the error code was not generated internally
WebCore::PlatformBridge::rawResId id = WebCore::PlatformBridge::NoDomain;
if ((error.errorCode() == ErrorFile ||
error.errorCode() == ErrorFileNotFound) &&
(!error.localizedDescription().isEmpty())) {
id = WebCore::PlatformBridge::LoadError;
}
String filename = m_webFrame->getRawResourceFilename(id);
if (filename.isEmpty())
return;
// Grab the error page from the asset manager
Asset* a = am->openNonAsset(
filename.utf8().data(), Asset::ACCESS_BUFFER);
if (!a)
return;
// Take the failing url and encode html entities so javascript urls are not
// executed.
CString failingUrl = error.failingURL().utf8();
WTF::Vector<char> url;
int len = failingUrl.length();
const char* data = failingUrl.data();
for (int i = 0; i < len; i++) {
char c = data[i];
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9'))
url.append(c);
else {
char buf[16];
int res = sprintf(buf, "&#%d;", c);
buf[res] = 0;
url.append(buf, res);
}
}
// Replace all occurances of %s with the failing url.
String s = UTF8Encoding().decode((const char*)a->getBuffer(false), a->getLength());
// samsung shkim
// \frameworks\base\core\res\res\raw-XX\nodomain.html or loaderror.html
// These error pages does not have <viewport> tag, it is loaded as low zoom scale
if( s.contains( "viewport" ) == false )
s = s.replace( "<head>", "<head> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=no\"/>" );
s = s.replace("%s", String(url.data(), url.size()));
// Replace all occurances of %e with the error text
s = s.replace("%e", error.localizedDescription());
// Create the request and the substitute data and tell the FrameLoader to
// load with the replacement data.
// use KURL(const char*) as KURL(const String& url) can trigger ASSERT for
// invalidate URL string.
loadDataIntoFrame(m_frame, KURL(ParsedURLString, data), error.failingURL(), s);
// Delete the asset.
delete a;
}
static void WebHistoryClose(JNIEnv* env, jobject obj, jint frame)
{
LOG_ASSERT(frame, "Close needs a valid Frame pointer!");
WebCore::Frame* pFrame = (WebCore::Frame*)frame;
WebCore::BackForwardList* list = pFrame->page()->backForwardList();
RefPtr<WebCore::HistoryItem> current = list->currentItem();
// Remove each item instead of using close(). close() is intended to be used
// right before the list is deleted.
WebCore::HistoryItemVector& entries = list->entries();
int size = entries.size();
for (int i = size - 1; i >= 0; --i)
list->removeItem(entries[i].get());
// Add the current item back to the list.
if (current) {
current->setBridge(0);
// addItem will update the children to match the newly created bridge
list->addItem(current);
/*
* The Grand Prix site uses anchor navigations to change the display.
* WebKit tries to be smart and not load child frames that have the
* same history urls during an anchor navigation. This means that the
* current history item stored in the child frame's loader does not
* match the item found in the history tree. If we remove all the
* entries in the back/foward list, we have to restore the entire tree
* or else a HistoryItem might have a deleted parent.
*
* In order to restore the history tree correctly, we have to look up
* all the frames first and then look up the history item. We do this
* because the history item in the tree may be null at this point.
* Unfortunately, a HistoryItem can only search its immediately
* children so we do a breadth-first rebuild of the tree.
*/
// Keep a small list of child frames to traverse.
WTF::Vector<WebCore::Frame*> frameQueue;
// Fix the top-level item.
pFrame->loader()->history()->setCurrentItem(current.get());
WebCore::Frame* child = pFrame->tree()->firstChild();
// Remember the parent history item so we can search for a child item.
RefPtr<WebCore::HistoryItem> parent = current;
while (child) {
// Use the old history item since the current one may have a
// deleted parent.
WebCore::HistoryItem* item = parent->childItemWithTarget(child->tree()->name());
child->loader()->history()->setCurrentItem(item);
// Append the first child to the queue if it exists. If there is no
// item, then we do not need to traverse the children since there
// will be no parent history item.
WebCore::Frame* firstChild;
if (item && (firstChild = child->tree()->firstChild()))
frameQueue.append(firstChild);
child = child->tree()->nextSibling();
// If we don't have a sibling for this frame and the queue isn't
// empty, use the next entry in the queue.
if (!child && !frameQueue.isEmpty()) {
child = frameQueue.at(0);
frameQueue.remove(0);
// Figure out the parent history item used when searching for
// the history item to use.
parent = child->tree()->parent()->loader()->history()->currentItem();
}
}
}
}
static bool read_item_recursive(WebCore::HistoryItem* newItem,
const char** pData, int length)
{
if (!pData || length < HISTORY_MIN_SIZE)
return false;
const WebCore::TextEncoding& e = WebCore::UTF8Encoding();
const char* data = *pData;
const char* end = data + length;
int sizeofUnsigned = (int)sizeof(unsigned);
// Read the original url
// Read the expected length of the string.
int l;
memcpy(&l, data, sizeofUnsigned);
// Increment data pointer by the size of an unsigned int.
data += sizeofUnsigned;
if (l) {
LOGV("Original url %d %.*s", l, l, data);
// If we have a length, check if that length exceeds the data length
// and return null if there is not enough data.
if (data + l < end)
newItem->setOriginalURLString(e.decode(data, l));
else
return false;
// Increment the data pointer by the length of the string.
data += l;
}
// Check if we have enough data left to continue.
if (end - data < sizeofUnsigned)
return false;
// Read the url
memcpy(&l, data, sizeofUnsigned);
data += sizeofUnsigned;
if (l) {
LOGV("Url %d %.*s", l, l, data);
if (data + l < end)
newItem->setURLString(e.decode(data, l));
else
return false;
data += l;
}
if (end - data < sizeofUnsigned)
return false;
// Read the title
memcpy(&l, data, sizeofUnsigned);
data += sizeofUnsigned;
if (l) {
LOGV("Title %d %.*s", l, l, data);
if (data + l < end)
newItem->setTitle(e.decode(data, l));
else
return false;
data += l;
}
if (end - data < sizeofUnsigned)
return false;
// Generate a new ResourceRequest object for populating form information.
WebCore::String formContentType;
WTF::PassRefPtr<WebCore::FormData> formData = NULL;
// Read the form content type
memcpy(&l, data, sizeofUnsigned);
data += sizeofUnsigned;
if (l) {
LOGV("Content type %d %.*s", l, l, data);
if (data + l < end)
formContentType = e.decode(data, l);
else
return false;
data += l;
}
if (end - data < sizeofUnsigned)
return false;
// Read the form data
memcpy(&l, data, sizeofUnsigned);
data += sizeofUnsigned;
if (l) {
LOGV("Form data %d %.*s", l, l, data);
if (data + l < end)
formData = WebCore::FormData::create(data, l);
else
return false;
data += l;
// Read the identifier
{
int64_t id;
int size = (int)sizeof(int64_t);
memcpy(&id, data, size);
data += size;
if (id)
formData->setIdentifier(id);
}
}
if (end - data < sizeofUnsigned)
return false;
// Set up the form info
if (formData != NULL) {
WebCore::ResourceRequest r;
r.setHTTPMethod("POST");
r.setHTTPContentType(formContentType);
r.setHTTPBody(formData);
newItem->setFormInfoFromRequest(r);
}
// Read the target
memcpy(&l, data, sizeofUnsigned);
data += sizeofUnsigned;
if (l) {
LOGV("Target %d %.*s", l, l, data);
if (data + l < end)
newItem->setTarget(e.decode(data, l));
else
return false;
data += l;
}
if (end - data < sizeofUnsigned)
return false;
AndroidWebHistoryBridge* bridge = newItem->bridge();
LOG_ASSERT(bridge, "There should be a bridge object during inflate");
// Read the screen scale
memcpy(&l, data, sizeofUnsigned);
LOGV("Screen scale %d", l);
bridge->setScale(l);
data += sizeofUnsigned;
memcpy(&l, data, sizeofUnsigned);
LOGV("Screen width scale %d", l);
bridge->setScreenWidthScale(l);
data += sizeofUnsigned;
if (end - data < sizeofUnsigned)
return false;
// Read the document state
memcpy(&l, data, sizeofUnsigned);
LOGV("Document state %d", l);
data += sizeofUnsigned;
if (l) {
// Check if we have enough data to at least parse the sizes of each
// document state string.
if (data + l * sizeofUnsigned >= end)
return false;
// Create a new vector and reserve enough space for the document state.
WTF::Vector<WebCore::String> docState;
docState.reserveCapacity(l);
while (l--) {
// Check each time if we have enough to parse the length of the next
// string.
if (end - data < sizeofUnsigned)
return false;
int strLen;
memcpy(&strLen, data, sizeofUnsigned);
data += sizeofUnsigned;
if (data + strLen < end)
docState.append(e.decode(data, strLen));
else
return false;
LOGV("\t\t%d %.*s", strLen, strLen, data);
data += strLen;
}
newItem->setDocumentState(docState);
}
// Check if we have enough to read the next byte
if (data >= end)
return false;
// Read is target item
// Cast the value to unsigned char in order to make a negative value larger
// than 1. A value that is not 0 or 1 is a failure.
unsigned char c = (unsigned char)data[0];
if (c > 1)
return false;
LOGV("Target item %d", c);
newItem->setIsTargetItem((bool)c);
data++;
if (end - data < sizeofUnsigned)
return false;
// Read the child count
memcpy(&l, data, sizeofUnsigned);
LOGV("Child count %d", l);
data += sizeofUnsigned;
*pData = data;
if (l) {
// Check if we have the minimum amount need to parse l children.
if (data + l * HISTORY_MIN_SIZE >= end)
return false;
while (l--) {
// No need to check the length each time because read_item_recursive
// will return null if there isn't enough data left to parse.
WTF::PassRefPtr<WebCore::HistoryItem> child = WebCore::HistoryItem::create();
// Set a bridge that will not call into java.
child->setBridge(new WebHistoryItem(static_cast<WebHistoryItem*>(bridge)));
// Read the child item.
if (!read_item_recursive(child.get(), pData, end - data)) {
child.clear();
return false;
}
child->bridge()->setActive();
newItem->addChildItem(child);
}
}
return true;
}
BaseTileTexture* TilesManager::getAvailableTexture(BaseTile* owner)
{
android::Mutex::Autolock lock(m_texturesLock);
// Sanity check that the tile does not already own a texture
if (owner->backTexture() && owner->backTexture()->owner() == owner) {
XLOG("same owner (%d, %d), getAvailableBackTexture(%x) => texture %x",
owner->x(), owner->y(), owner, owner->backTexture());
if (owner->isLayerTile())
m_availableTilesTextures.remove(m_availableTilesTextures.find(owner->backTexture()));
else
m_availableTextures.remove(m_availableTextures.find(owner->backTexture()));
return owner->backTexture();
}
WTF::Vector<BaseTileTexture*>* availableTexturePool;
if (owner->isLayerTile()) {
availableTexturePool = &m_availableTilesTextures;
} else {
availableTexturePool = &m_availableTextures;
}
// The heuristic for selecting a texture is as follows:
// 1. Skip textures currently being painted, they can't be painted while
// busy anyway
// 2. If a tile isn't owned, break with that one
// 3. Don't let tiles acquire their front textures
// 4. If we find a tile in the same page with a different scale,
// it's old and not visible. Break with that one
// 5. Otherwise, use the least recently prepared tile, but ignoring tiles
// drawn in the last frame to avoid flickering
BaseTileTexture* farthestTexture = 0;
unsigned long long oldestDrawCount = getDrawGLCount() - 1;
const unsigned int max = availableTexturePool->size();
for (unsigned int i = 0; i < max; i++) {
BaseTileTexture* texture = (*availableTexturePool)[i];
BaseTile* currentOwner = static_cast<BaseTile*>(texture->owner());
if (texture->busy()) {
// don't bother, since the acquire() will likely fail
continue;
}
if (!currentOwner) {
// unused texture! take it!
farthestTexture = texture;
break;
}
if (currentOwner == owner) {
// Don't let a tile acquire its own front texture, as the
// acquisition logic doesn't handle that
continue;
}
if (currentOwner->painter() == owner->painter() && texture->scale() != owner->scale()) {
// if we render the back page with one scale, then another while
// still zooming, we recycle the tiles with the old scale instead of
// taking ones from the front page
farthestTexture = texture;
break;
}
unsigned long long textureDrawCount = currentOwner->drawCount();
if (oldestDrawCount > textureDrawCount) {
farthestTexture = texture;
oldestDrawCount = textureDrawCount;
}
}
if (farthestTexture) {
BaseTile* previousOwner = static_cast<BaseTile*>(farthestTexture->owner());
if (farthestTexture->acquire(owner)) {
if (previousOwner) {
previousOwner->removeTexture(farthestTexture);
XLOG("%s texture %p stolen from tile %d, %d for %d, %d, drawCount was %llu (now %llu)",
owner->isLayerTile() ? "LAYER" : "BASE",
farthestTexture, previousOwner->x(), previousOwner->y(),
owner->x(), owner->y(),
oldestDrawCount, getDrawGLCount());
}
availableTexturePool->remove(availableTexturePool->find(farthestTexture));
return farthestTexture;
}
} else {
if (owner->isLayerTile()) {
// couldn't find a tile for a layer, layers shouldn't request redraw
// TODO: once we do layer prefetching, don't set this for those
// tiles
m_layerTexturesRemain = false;
}
}
XLOG("Couldn't find an available texture for %s tile %x (%d, %d) out of %d available",
owner->isLayerTile() ? "LAYER" : "BASE",
owner, owner->x(), owner->y(), max);
#ifdef DEBUG
printTextures();
#endif // DEBUG
return 0;
}
static bool readItemRecursive(WebCore::HistoryItem* newItem,
const char** pData, int length)
{
if (!pData || length < HISTORY_MIN_SIZE) {
ALOGW("readItemRecursive() bad params; pData=%p length=%d", pData, length);
return false;
}
const char* data = *pData;
const char* end = data + length;
String content;
// Read the original url
if (readString(data, end, content, "Original url"))
newItem->setOriginalURLString(content);
else
return false;
// Read the url
if (readString(data, end, content, "Url"))
newItem->setURLString(content);
else
return false;
// Read the title
if (readString(data, end, content, "Title"))
newItem->setTitle(content);
else
return false;
// Generate a new ResourceRequest object for populating form information.
// Read the form content type
WTF::String formContentType;
if (!readString(data, end, formContentType, "Content type"))
return false;
// Read the form data size
unsigned formDataSize;
if (!readUnsigned(data, end, formDataSize, "Form data size"))
return false;
// Read the form data
WTF::RefPtr<WebCore::FormData> formData;
if (formDataSize) {
ALOGV("Reading Form data %d %.*s", formDataSize, formDataSize, data);
if ((end < data) || ((size_t)(end - data) < formDataSize)) {
ALOGW("\tNot enough data to read form data; returning");
return false;
}
formData = WebCore::FormData::create(data, formDataSize);
data += formDataSize;
// Read the identifier
int64_t id;
if (!readInt64(data, end, id, "Form id"))
return false;
if (id)
formData->setIdentifier(id);
}
// Set up the form info
if (formData != NULL) {
WebCore::ResourceRequest r;
r.setHTTPMethod("POST");
r.setHTTPContentType(formContentType);
r.setHTTPBody(formData);
newItem->setFormInfoFromRequest(r);
}
// Read the target
if (readString(data, end, content, "Target"))
newItem->setTarget(content);
else
return false;
AndroidWebHistoryBridge* bridge = newItem->bridge();
ALOG_ASSERT(bridge, "There should be a bridge object during inflate");
// Read the screen scale
float fValue;
if (readFloat(data, end, fValue, "Screen scale"))
bridge->setScale(fValue);
else
return false;
// Read the text wrap scale
if (readFloat(data, end, fValue, "Text wrap scale"))
bridge->setTextWrapScale(fValue);
else
return false;
// Read scroll position.
int scrollX;
if (!readInt(data, end, scrollX, "Scroll pos x"))
return false;
int scrollY;
if (!readInt(data, end, scrollY, "Scroll pos y"))
return false;
newItem->setScrollPoint(IntPoint(scrollX, scrollY));
// Read the document state
unsigned docStateCount;
if (!readUnsigned(data, end, docStateCount, "Doc state count"))
return false;
if (docStateCount) {
// Create a new vector and reserve enough space for the document state.
WTF::Vector<WTF::String> docState;
docState.reserveCapacity(docStateCount);
while (docStateCount--) {
// Read a document state string
if (readString(data, end, content, "Document state"))
docState.append(content);
else
return false;
}
newItem->setDocumentState(docState);
}
// Read is target item
bool c;
if (readBool(data, end, c, "Target item"))
newItem->setIsTargetItem(c);
else
return false;
// Read the child count
unsigned count;
if (!readUnsigned(data, end, count, "Child count"))
return false;
*pData = data;
if (count) {
while (count--) {
// No need to check the length each time because read_item_recursive
// will return null if there isn't enough data left to parse.
WTF::RefPtr<WebCore::HistoryItem> child = WebCore::HistoryItem::create();
// Set a bridge that will not call into java.
child->setBridge(new WebHistoryItem(static_cast<WebHistoryItem*>(bridge)));
// Read the child item.
if (!readItemRecursive(child.get(), pData, end - data))
return false;
child->bridge()->setActive();
newItem->addChildItem(child);
}
}
return true;
}
static void writeItem(WTF::Vector<char>& vector, WebCore::HistoryItem* item)
{
// Original url
writeString(vector, item->originalURLString());
// Url
writeString(vector, item->urlString());
// Title
writeString(vector, item->title());
// Form content type
writeString(vector, item->formContentType());
// Form data
const WebCore::FormData* formData = item->formData();
if (formData) {
WTF::String flattenedFormData = formData->flattenToString();
writeString(vector, flattenedFormData);
if (!flattenedFormData.isEmpty()) {
// save the identifier as it is not included in the flatten data
int64_t id = formData->identifier();
vector.append((char*)&id, sizeof(int64_t));
}
} else
writeString(vector, WTF::String()); // Empty constructor does not allocate a buffer.
// Target
writeString(vector, item->target());
AndroidWebHistoryBridge* bridge = item->bridge();
ALOG_ASSERT(bridge, "We should have a bridge here!");
// Screen scale
const float scale = bridge->scale();
ALOGV("Writing scale %f", scale);
vector.append((char*)&scale, sizeof(float));
const float textWrapScale = bridge->textWrapScale();
ALOGV("Writing text wrap scale %f", textWrapScale);
vector.append((char*)&textWrapScale, sizeof(float));
// Scroll position.
const int scrollX = item->scrollPoint().x();
vector.append((char*)&scrollX, sizeof(int));
const int scrollY = item->scrollPoint().y();
vector.append((char*)&scrollY, sizeof(int));
// Document state
const WTF::Vector<WTF::String>& docState = item->documentState();
WTF::Vector<WTF::String>::const_iterator end = docState.end();
unsigned stateSize = docState.size();
ALOGV("Writing docState %d", stateSize);
vector.append((char*)&stateSize, sizeof(unsigned));
for (WTF::Vector<WTF::String>::const_iterator i = docState.begin(); i != end; ++i) {
writeString(vector, *i);
}
// Is target item
ALOGV("Writing isTargetItem %d", item->isTargetItem());
vector.append((char)item->isTargetItem());
// Children count
unsigned childCount = item->children().size();
ALOGV("Writing childCount %d", childCount);
vector.append((char*)&childCount, sizeof(unsigned));
}
TileTexture* TilesManager::getAvailableTexture(Tile* owner)
{
android::Mutex::Autolock lock(m_texturesLock);
WTF::Vector<TileTexture*>* availableTexturePool;
if (owner->isLayerTile())
availableTexturePool = &m_availableTilesTextures;
else
availableTexturePool = &m_availableTextures;
// Sanity check that the tile does not already own a texture
if (owner->backTexture() && owner->backTexture()->owner() == owner) {
int removeIndex = availableTexturePool->find(owner->backTexture());
// TODO: investigate why texture isn't found
if (removeIndex >= 0)
availableTexturePool->remove(removeIndex);
return owner->backTexture();
}
// The heuristic for selecting a texture is as follows:
// 1. Skip textures currently being painted, they can't be painted while
// busy anyway
// 2. If a tile isn't owned, break with that one
// 3. Don't let tiles acquire their front textures
// 4. Otherwise, use the least recently prepared tile, but ignoring tiles
// drawn in the last frame to avoid flickering
TileTexture* farthestTexture = 0;
unsigned long long oldestDrawCount = getDrawGLCount() - 1;
const unsigned int max = availableTexturePool->size();
for (unsigned int i = 0; i < max; i++) {
TileTexture* texture = (*availableTexturePool)[i];
Tile* currentOwner = static_cast<Tile*>(texture->owner());
if (!currentOwner) {
// unused texture! take it!
farthestTexture = texture;
break;
}
if (currentOwner == owner) {
// Don't let a tile acquire its own front texture, as the
// acquisition logic doesn't handle that
continue;
}
unsigned long long textureDrawCount = currentOwner->drawCount();
if (oldestDrawCount > textureDrawCount) {
farthestTexture = texture;
oldestDrawCount = textureDrawCount;
}
}
if (farthestTexture) {
Tile* previousOwner = static_cast<Tile*>(farthestTexture->owner());
if (farthestTexture->acquire(owner)) {
if (previousOwner) {
previousOwner->removeTexture(farthestTexture);
ALOGV("%s texture %p stolen from tile %d, %d for %d, %d, drawCount was %llu (now %llu)",
owner->isLayerTile() ? "LAYER" : "BASE",
farthestTexture, previousOwner->x(), previousOwner->y(),
owner->x(), owner->y(),
oldestDrawCount, getDrawGLCount());
}
availableTexturePool->remove(availableTexturePool->find(farthestTexture));
return farthestTexture;
}
} else {
if (owner->isLayerTile()) {
// couldn't find a tile for a layer, layers shouldn't request redraw
// TODO: once we do layer prefetching, don't set this for those
// tiles
m_layerTexturesRemain = false;
}
}
ALOGV("Couldn't find an available texture for %s tile %x (%d, %d) out of %d available",
owner->isLayerTile() ? "LAYER" : "BASE",
owner, owner->x(), owner->y(), max);
#ifdef DEBUG
printTextures();
#endif // DEBUG
return 0;
}
Value RelationOp::doEvaluate() const
{
Value lhs( subExpr( 0 )->evaluate() );
Value rhs( subExpr( 1 )->evaluate() );
if (lhs.isNodeset() || rhs.isNodeset())
{
// If both are nodesets, or one is a string our
// comparisons are based on strings.
if ((lhs.isNodeset() && rhs.isNodeset()) ||
(lhs.isString() || rhs.isString())) {
WTF::Vector<DOM::DOMString> leftStrings;
WTF::Vector<DOM::DOMString> rightStrings;
stringify(lhs, &leftStrings);
stringify(rhs, &rightStrings);
for (unsigned pl = 0; pl < leftStrings.size(); ++pl) {
for (unsigned pr = 0; pr < rightStrings.size(); ++pr) {
if (compareStrings(leftStrings[pl], rightStrings[pr]))
return Value(true);
} // pr
} // pl
return Value(false);
}
// If one is a number, we do a number-based comparison
if (lhs.isNumber() || rhs.isNumber()) {
WTF::Vector<double> leftNums;
WTF::Vector<double> rightNums;
numify(lhs, &leftNums);
numify(rhs, &rightNums);
for (unsigned pl = 0; pl < leftNums.size(); ++pl) {
for (unsigned pr = 0; pr < rightNums.size(); ++pr) {
if (compareNumbers(leftNums[pl], rightNums[pr]))
return Value(true);
} // pr
} // pl
return Value(false);
}
// Has to be a boolean-based comparison.
// These ones are simpler, since we just convert the nodeset to a bool
assert(lhs.isBoolean() || rhs.isBoolean());
if (lhs.isNodeset())
lhs = Value(lhs.toBoolean());
else
rhs = Value(rhs.toBoolean());
} // nodeset comparisons
if (opCode == OP_EQ || opCode == OP_NE) {
bool equal;
if ( lhs.isBoolean() || rhs.isBoolean() ) {
equal = ( lhs.toBoolean() == rhs.toBoolean() );
} else if ( lhs.isNumber() || rhs.isNumber() ) {
equal = ( lhs.toNumber() == rhs.toNumber() );
} else {
equal = ( lhs.toString() == rhs.toString() );
}
if ( opCode == OP_EQ )
return Value( equal );
else
return Value( !equal );
}
// For other ops, we always convert to numbers
double leftVal = lhs.toNumber(), rightVal = rhs.toNumber();
return Value(compareNumbers(leftVal, rightVal));
}