bool CppVariant::invokeDefault(const CppVariant* arguments, uint32_t argumentCount,
CppVariant& result) const
{
WEBKIT_ASSERT(isObject());
NPObject* npObject = value.objectValue;
NPVariant r;
bool status = WebBindings::invokeDefault(0, npObject, arguments, argumentCount, &r);
result.set(r);
return status;
}
void TestPlugin::drawPrimitive()
{
WEBKIT_ASSERT(m_scene.primitive == PrimitiveTriangle);
WEBKIT_ASSERT(m_scene.vbo);
WEBKIT_ASSERT(m_scene.program);
m_context->useProgram(m_scene.program);
// Bind primitive color.
float color[4];
premultiplyAlpha(m_scene.primitiveColor, m_scene.opacity, color);
m_context->uniform4f(m_scene.colorLocation, color[0], color[1], color[2], color[3]);
// Bind primitive vertices.
m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
m_context->enableVertexAttribArray(m_scene.positionLocation);
m_context->vertexAttribPointer(m_scene.positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
m_context->drawArrays(GL_TRIANGLES, 0, 3);
}
WebFilterOperation::WebFilterOperation(FilterType type, SkScalar matrix[20])
: m_type(type)
, m_amount(0)
, m_dropShadowOffset(0, 0)
, m_dropShadowColor(0)
, m_zoomInset(0)
{
WEBKIT_ASSERT(m_type == FilterTypeColorMatrix);
memcpy(m_matrix, matrix, sizeof(m_matrix));
}
bool CppVariant::invoke(const string& method, const CppVariant* arguments,
uint32_t argumentCount, CppVariant& result) const
{
WEBKIT_ASSERT(isObject());
NPIdentifier methodName = WebBindings::getStringIdentifier(method.c_str());
NPObject* npObject = value.objectValue;
if (!WebBindings::hasMethod(0, npObject, methodName))
return false;
NPVariant r;
bool status = WebBindings::invoke(0, npObject, methodName, arguments, argumentCount, &r);
result.set(r);
return status;
}
CppVariant* CppBoundClass::getAsCppVariant()
{
if (!m_selfVariant.isObject()) {
// Create an NPObject using our static NPClass. The first argument (a
// plugin's instance handle) is passed through to the allocate function
// directly, and we don't use it, so it's ok to be 0.
NPObject* npObj = WebBindings::createObject(0, &CppNPObject::npClass);
CppNPObject* obj = reinterpret_cast<CppNPObject*>(npObj);
obj->boundClass = this;
m_selfVariant.set(npObj);
WebBindings::releaseObject(npObj); // CppVariant takes the reference.
}
WEBKIT_ASSERT(m_selfVariant.isObject());
return &m_selfVariant;
}
TestPlugin::TestPlugin(WebFrame* frame, const WebPluginParams& params, WebTestDelegate* delegate)
: m_frame(frame)
, m_delegate(delegate)
, m_container(0)
, m_context(0)
, m_touchEventRequest(WebPluginContainer::TouchEventRequestTypeNone)
, m_reRequestTouchEvents(false)
, m_printEventDetails(false)
, m_printUserGestureStatus(false)
, m_canProcessDrag(false)
{
static const WebString kAttributePrimitive = WebString::fromUTF8("primitive");
static const WebString kAttributeBackgroundColor = WebString::fromUTF8("background-color");
static const WebString kAttributePrimitiveColor = WebString::fromUTF8("primitive-color");
static const WebString kAttributeOpacity = WebString::fromUTF8("opacity");
static const WebString kAttributeAcceptsTouch = WebString::fromUTF8("accepts-touch");
static const WebString kAttributeReRequestTouchEvents = WebString::fromUTF8("re-request-touch");
static const WebString kAttributePrintEventDetails = WebString::fromUTF8("print-event-details");
static const WebString kAttributeCanProcessDrag = WebString::fromUTF8("can-process-drag");
static const WebString kAttributePrintUserGestureStatus = WebString::fromUTF8("print-user-gesture-status");
WEBKIT_ASSERT(params.attributeNames.size() == params.attributeValues.size());
size_t size = params.attributeNames.size();
for (size_t i = 0; i < size; ++i) {
const WebString& attributeName = params.attributeNames[i];
const WebString& attributeValue = params.attributeValues[i];
if (attributeName == kAttributePrimitive)
m_scene.primitive = parsePrimitive(attributeValue);
else if (attributeName == kAttributeBackgroundColor)
parseColor(attributeValue, m_scene.backgroundColor);
else if (attributeName == kAttributePrimitiveColor)
parseColor(attributeValue, m_scene.primitiveColor);
else if (attributeName == kAttributeOpacity)
m_scene.opacity = parseOpacity(attributeValue);
else if (attributeName == kAttributeAcceptsTouch)
m_touchEventRequest = parseTouchEventRequestType(attributeValue);
else if (attributeName == kAttributeReRequestTouchEvents)
m_reRequestTouchEvents = parseBoolean(attributeValue);
else if (attributeName == kAttributePrintEventDetails)
m_printEventDetails = parseBoolean(attributeValue);
else if (attributeName == kAttributeCanProcessDrag)
m_canProcessDrag = parseBoolean(attributeValue);
else if (attributeName == kAttributePrintUserGestureStatus)
m_printUserGestureStatus = parseBoolean(attributeValue);
}
}
bool TestPlugin::initPrimitive()
{
WEBKIT_ASSERT(m_scene.primitive == PrimitiveTriangle);
m_scene.vbo = m_context->createBuffer();
if (!m_scene.vbo)
return false;
const float vertices[] = {
0.0f, 0.8f, 0.0f,
-0.8f, -0.8f, 0.0f,
0.8f, -0.8f, 0.0f };
m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
m_context->bufferData(GL_ARRAY_BUFFER, sizeof(vertices), 0, GL_STATIC_DRAW);
m_context->bufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
return true;
}
vector<string> CppVariant::toStringVector() const
{
WEBKIT_ASSERT(isObject());
vector<string> stringVector;
NPObject* npValue = value.objectValue;
NPIdentifier lengthId = WebBindings::getStringIdentifier("length");
if (!WebBindings::hasProperty(0, npValue, lengthId))
return stringVector;
NPVariant lengthValue;
if (!WebBindings::getProperty(0, npValue, lengthId, &lengthValue))
return stringVector;
int length = 0;
// The length is a double in some cases.
if (NPVARIANT_IS_DOUBLE(lengthValue))
length = static_cast<int>(NPVARIANT_TO_DOUBLE(lengthValue));
else if (NPVARIANT_IS_INT32(lengthValue))
length = NPVARIANT_TO_INT32(lengthValue);
WebBindings::releaseVariantValue(&lengthValue);
// For sanity, only allow 100 items.
length = min(100, length);
for (int i = 0; i < length; ++i) {
// Get each of the items.
char indexInChar[20]; // Enough size to store 32-bit integer
snprintf(indexInChar, 20, "%d", i);
string index(indexInChar);
NPIdentifier indexId = WebBindings::getStringIdentifier(index.c_str());
if (!WebBindings::hasProperty(0, npValue, indexId))
continue;
NPVariant indexValue;
if (!WebBindings::getProperty(0, npValue, indexId, &indexValue))
continue;
if (NPVARIANT_IS_STRING(indexValue)) {
string item(NPVARIANT_TO_STRING(indexValue).UTF8Characters,
NPVARIANT_TO_STRING(indexValue).UTF8Length);
stringVector.push_back(item);
}
WebBindings::releaseVariantValue(&indexValue);
}
return stringVector;
}
bool MockGrammarCheck::checkGrammarOfString(const WebString& text, vector<WebTextCheckingResult>* results)
{
WEBKIT_ASSERT(results);
string16 stringText = text;
if (find_if(stringText.begin(), stringText.end(), isASCIIAlpha) == stringText.end())
return true;
// Find matching grammatical errors from known ones. This function has to
// check all errors because the given text may consist of two or more
// sentences that have grammatical errors.
static const struct {
const char* text;
int location;
int length;
} grammarErrors[] = {
{"I have a issue.", 7, 1},
{"I have an grape.", 7, 2},
{"I have an kiwi.", 7, 2},
{"I have an muscat.", 7, 2},
{"You has the right.", 4, 3},
{"apple orange zz.", 0, 16},
{"apple zz orange.", 0, 16},
{"apple,zz,orange.", 0, 16},
{"orange,zz,apple.", 0, 16},
{"the the adlj adaasj sdklj. there there", 0, 38},
{"zz apple orange.", 0, 16},
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(grammarErrors); ++i) {
size_t offset = 0;
string16 error(grammarErrors[i].text, grammarErrors[i].text + strlen(grammarErrors[i].text));
while ((offset = stringText.find(error, offset)) != string16::npos) {
results->push_back(WebTextCheckingResult(WebTextCheckingTypeGrammar, offset + grammarErrors[i].location, grammarErrors[i].length));
offset += grammarErrors[i].length;
}
}
return false;
}
bool CppVariant::toBoolean() const
{
WEBKIT_ASSERT(isBool());
return value.boolValue;
}
string CppVariant::toString() const
{
WEBKIT_ASSERT(isString());
return string(value.stringValue.UTF8Characters,
value.stringValue.UTF8Length);
}
float WebSpeechGrammar::weight() const
{
WEBKIT_ASSERT(m_private.get());
return m_private->weight();
}
WebURL WebSpeechGrammar::src() const
{
WEBKIT_ASSERT(m_private.get());
return m_private->src();
}
bool MockSpellCheck::spellCheckWord(const WebString& text, int* misspelledOffset, int* misspelledLength)
{
WEBKIT_ASSERT(misspelledOffset);
WEBKIT_ASSERT(misspelledLength);
// Initialize this spellchecker.
initializeIfNeeded();
// Reset the result values as our spellchecker does.
*misspelledOffset = 0;
*misspelledLength = 0;
// Convert to a string16 because we store string16 instances in
// m_misspelledWords and WebString has no find().
string16 stringText = text;
int skippedLength = 0;
while (!stringText.empty()) {
// Extract the first possible English word from the given string.
// The given string may include non-ASCII characters or numbers. So, we
// should filter out such characters before start looking up our
// misspelled-word table.
// (This is a simple version of our SpellCheckWordIterator class.)
// If the given string doesn't include any ASCII characters, we can treat the
// string as valid one.
string16::iterator firstChar = find_if(stringText.begin(), stringText.end(), isASCIIAlpha);
if (firstChar == stringText.end())
return true;
int wordOffset = distance(stringText.begin(), firstChar);
int maxWordLength = static_cast<int>(stringText.length()) - wordOffset;
int wordLength;
string16 word;
// Look up our misspelled-word table to check if the extracted word is a
// known misspelled word, and return the offset and the length of the
// extracted word if this word is a known misspelled word.
// (See the comment in MockSpellCheck::initializeIfNeeded() why we use a
// misspelled-word table.)
for (size_t i = 0; i < m_misspelledWords.size(); ++i) {
wordLength = static_cast<int>(m_misspelledWords.at(i).length()) > maxWordLength ? maxWordLength : static_cast<int>(m_misspelledWords.at(i).length());
word = stringText.substr(wordOffset, wordLength);
if (word == m_misspelledWords.at(i) && (static_cast<int>(stringText.length()) == wordOffset + wordLength || isNotASCIIAlpha(stringText[wordOffset + wordLength]))) {
*misspelledOffset = wordOffset + skippedLength;
*misspelledLength = wordLength;
break;
}
}
if (*misspelledLength > 0)
break;
string16::iterator lastChar = find_if(stringText.begin() + wordOffset, stringText.end(), isNotASCIIAlpha);
if (lastChar == stringText.end())
wordLength = static_cast<int>(stringText.length()) - wordOffset;
else
wordLength = distance(firstChar, lastChar);
WEBKIT_ASSERT(0 < wordOffset + wordLength);
stringText = stringText.substr(wordOffset + wordLength);
skippedLength += wordOffset + wordLength;
}
return false;
}
