bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, const SimpleFontData* fontData, GlyphBuffer* glyphBuffer) { // Determine the string for this item. const UChar* str = cp + m_items[i].iCharPos; int len = m_items[i+1].iCharPos - m_items[i].iCharPos; SCRIPT_ITEM item = m_items[i]; // Set up buffers to hold the results of shaping the item. Vector<WORD> glyphs; Vector<WORD> clusters; Vector<SCRIPT_VISATTR> visualAttributes; clusters.resize(len); // Shape the item. // The recommended size for the glyph buffer is 1.5 * the character length + 16 in the uniscribe docs. // Apparently this is a good size to avoid having to make repeated calls to ScriptShape. glyphs.resize(1.5 * len + 16); visualAttributes.resize(glyphs.size()); if (!shape(str, len, item, fontData, glyphs, clusters, visualAttributes)) return true; // We now have a collection of glyphs. Vector<GOFFSET> offsets; Vector<int> advances; offsets.resize(glyphs.size()); advances.resize(glyphs.size()); int glyphCount = 0; HRESULT placeResult = ScriptPlace(0, fontData->scriptCache(), glyphs.data(), glyphs.size(), visualAttributes.data(), &item.a, advances.data(), offsets.data(), 0); if (placeResult == E_PENDING) { // The script cache isn't primed with enough info yet. We need to select our HFONT into // a DC and pass the DC in to ScriptPlace. HWndDC hdc(0); HFONT hfont = fontData->platformData().hfont(); HFONT oldFont = (HFONT)SelectObject(hdc, hfont); placeResult = ScriptPlace(hdc, fontData->scriptCache(), glyphs.data(), glyphs.size(), visualAttributes.data(), &item.a, advances.data(), offsets.data(), 0); SelectObject(hdc, oldFont); } if (FAILED(placeResult) || glyphs.isEmpty()) return true; // Convert all chars that should be treated as spaces to use the space glyph. // We also create a map that allows us to quickly go from space glyphs back to their corresponding characters. Vector<int> spaceCharacters(glyphs.size()); spaceCharacters.fill(-1); const float cLogicalScale = fontData->platformData().useGDI() ? 1.0f : 32.0f; float spaceWidth = fontData->spaceWidth() - fontData->syntheticBoldOffset(); unsigned logicalSpaceWidth = spaceWidth * cLogicalScale; for (int k = 0; k < len; k++) { UChar ch = *(str + k); bool treatAsSpace = Font::treatAsSpace(ch); bool treatAsZeroWidthSpace = Font::treatAsZeroWidthSpace(ch); if (treatAsSpace || treatAsZeroWidthSpace) { // Substitute in the space glyph at the appropriate place in the glyphs // array. glyphs[clusters[k]] = fontData->spaceGlyph(); advances[clusters[k]] = treatAsSpace ? logicalSpaceWidth : 0; if (treatAsSpace) spaceCharacters[clusters[k]] = m_currentCharacter + k + item.iCharPos; } } // Populate our glyph buffer with this information. bool hasExtraSpacing = m_font.letterSpacing() || m_font.wordSpacing() || m_padding; float leftEdge = m_runWidthSoFar; for (unsigned k = 0; k < glyphs.size(); k++) { Glyph glyph = glyphs[k]; float advance = advances[k] / cLogicalScale; float offsetX = offsets[k].du / cLogicalScale; float offsetY = offsets[k].dv / cLogicalScale; // Match AppKit's rules for the integer vs. non-integer rendering modes. float roundedAdvance = roundf(advance); if (!m_font.isPrinterFont() && !fontData->isSystemFont()) { advance = roundedAdvance; offsetX = roundf(offsetX); offsetY = roundf(offsetY); } advance += fontData->syntheticBoldOffset(); if (hasExtraSpacing) { // If we're a glyph with an advance, go ahead and add in letter-spacing. // That way we weed out zero width lurkers. This behavior matches the fast text code path. if (advance && m_font.letterSpacing()) advance += m_font.letterSpacing(); // Handle justification and word-spacing. int characterIndex = spaceCharacters[k]; // characterIndex is left at the initial value of -1 for glyphs that do not map back to treated-as-space characters. if (characterIndex != -1) { // Account for padding. WebCore uses space padding to justify text. // We distribute the specified padding over the available spaces in the run. if (m_padding) { // Use leftover padding if not evenly divisible by number of spaces. if (m_padding < m_padPerSpace) { advance += m_padding; m_padding = 0; } else { m_padding -= m_padPerSpace; advance += m_padPerSpace; } } // Account for word-spacing. if (characterIndex > 0 && !Font::treatAsSpace(*m_run.data16(characterIndex - 1)) && m_font.wordSpacing()) advance += m_font.wordSpacing(); } } m_runWidthSoFar += advance; // FIXME: We need to take the GOFFSETS for combining glyphs and store them in the glyph buffer // as well, so that when the time comes to draw those glyphs, we can apply the appropriate // translation. if (glyphBuffer) { FloatSize size(offsetX, -offsetY); glyphBuffer->add(glyph, fontData, advance, &size); } FloatRect glyphBounds = fontData->boundsForGlyph(glyph); glyphBounds.move(m_glyphOrigin.x(), m_glyphOrigin.y()); m_minGlyphBoundingBoxX = min(m_minGlyphBoundingBoxX, glyphBounds.x()); m_maxGlyphBoundingBoxX = max(m_maxGlyphBoundingBoxX, glyphBounds.maxX()); m_minGlyphBoundingBoxY = min(m_minGlyphBoundingBoxY, glyphBounds.y()); m_maxGlyphBoundingBoxY = max(m_maxGlyphBoundingBoxY, glyphBounds.maxY()); m_glyphOrigin.move(advance + offsetX, -offsetY); // Mutate the glyph array to contain our altered advances. if (m_computingOffsetPosition) advances[k] = advance; } while (m_computingOffsetPosition && m_offsetX >= leftEdge && m_offsetX < m_runWidthSoFar) { // The position is somewhere inside this run. int trailing = 0; ScriptXtoCP(m_offsetX - leftEdge, clusters.size(), glyphs.size(), clusters.data(), visualAttributes.data(), advances.data(), &item.a, &m_offsetPosition, &trailing); if (trailing && m_includePartialGlyphs && m_offsetPosition < len - 1) { m_offsetPosition += m_currentCharacter + m_items[i].iCharPos; m_offsetX += m_run.rtl() ? -trailing : trailing; } else { m_computingOffsetPosition = false; m_offsetPosition += m_currentCharacter + m_items[i].iCharPos; if (trailing && m_includePartialGlyphs) m_offsetPosition++; return false; } } return true; }
void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, SecurityCheckPolicy securityCheck) { // Any credential should have been removed from the cross-site requests. const KURL& requestURL = request.url(); m_options.securityCheck = securityCheck; ASSERT(m_sameOriginRequest || requestURL.user().isEmpty()); ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty()); if (m_async) { ThreadableLoaderOptions options = m_options; options.crossOriginCredentialPolicy = DoNotAskClientForCrossOriginCredentials; if (m_actualRequest) { // Don't sniff content or send load callbacks for the preflight request. options.sendLoadCallbacks = DoNotSendCallbacks; options.sniffContent = DoNotSniffContent; // Keep buffering the data for the preflight request. options.shouldBufferData = BufferData; } ResourceRequest newRequest(request); #if ENABLE(INSPECTOR) if (m_actualRequest) { // Because willSendRequest only gets called during redirects, we initialize the identifier and the first willSendRequest here. m_preflightRequestIdentifier = m_document->frame()->page()->progress()->createUniqueIdentifier(); ResourceResponse redirectResponse = ResourceResponse(); InspectorInstrumentation::willSendRequest(m_document->frame(), m_preflightRequestIdentifier, m_document->frame()->loader()->documentLoader(), newRequest, redirectResponse); } #endif ASSERT(!m_resource); m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest, options); if (m_resource) m_resource->addClient(this); return; } // FIXME: ThreadableLoaderOptions.sniffContent is not supported for synchronous requests. Vector<char> data; ResourceError error; ResourceResponse response; unsigned long identifier = std::numeric_limits<unsigned long>::max(); if (m_document->frame()) identifier = m_document->frame()->loader()->loadResourceSynchronously(request, m_options.allowCredentials, error, response, data); // No exception for file:/// resources, see <rdar://problem/4962298>. // Also, if we have an HTTP response, then it wasn't a network error in fact. if (!error.isNull() && !requestURL.isLocalFile() && response.httpStatusCode() <= 0) { m_client->didFail(error); return; } // FIXME: FrameLoader::loadSynchronously() does not tell us whether a redirect happened or not, so we guess by comparing the // request and response URLs. This isn't a perfect test though, since a server can serve a redirect to the same URL that was // requested. Also comparing the request and response URLs as strings will fail if the requestURL still has its credentials. if (requestURL != response.url() && !isAllowedRedirect(response.url())) { m_client->didFailRedirectCheck(); return; } didReceiveResponse(identifier, response); const char* bytes = static_cast<const char*>(data.data()); int len = static_cast<int>(data.size()); dataReceived(0, bytes, len); didFinishLoading(identifier, 0.0); }
void ContentLayerChromium::updateContents() { RenderLayerBacking* backing = static_cast<RenderLayerBacking*>(m_owner->client()); if (!backing || backing->paintingGoesToWindow()) return; ASSERT(drawsContent()); ASSERT(layerRenderer()); // FIXME: Remove this test when tiled layers are implemented. m_skipsDraw = false; if (!layerRenderer()->checkTextureSize(m_bounds)) { m_skipsDraw = true; return; } void* pixels = 0; IntRect dirtyRect(m_dirtyRect); IntSize requiredTextureSize; IntSize bitmapSize; requiredTextureSize = m_bounds; IntRect boundsRect(IntPoint(0, 0), m_bounds); // If the texture needs to be reallocated then we must redraw the entire // contents of the layer. if (requiredTextureSize != m_allocatedTextureSize) dirtyRect = boundsRect; else { // Clip the dirtyRect to the size of the layer to avoid drawing outside // the bounds of the backing texture. dirtyRect.intersect(boundsRect); } #if PLATFORM(SKIA) const SkBitmap* skiaBitmap = 0; OwnPtr<skia::PlatformCanvas> canvas; OwnPtr<PlatformContextSkia> skiaContext; OwnPtr<GraphicsContext> graphicsContext; canvas.set(new skia::PlatformCanvas(dirtyRect.width(), dirtyRect.height(), false)); skiaContext.set(new PlatformContextSkia(canvas.get())); // This is needed to get text to show up correctly. // FIXME: Does this take us down a very slow text rendering path? skiaContext->setDrawingToImageBuffer(true); graphicsContext.set(new GraphicsContext(reinterpret_cast<PlatformGraphicsContext*>(skiaContext.get()))); // Bring the canvas into the coordinate system of the paint rect. canvas->translate(static_cast<SkScalar>(-dirtyRect.x()), static_cast<SkScalar>(-dirtyRect.y())); m_owner->paintGraphicsLayerContents(*graphicsContext, dirtyRect); const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(false); skiaBitmap = &bitmap; ASSERT(skiaBitmap); SkAutoLockPixels lock(*skiaBitmap); SkBitmap::Config skiaConfig = skiaBitmap->config(); // FIXME: do we need to support more image configurations? if (skiaConfig == SkBitmap::kARGB_8888_Config) { pixels = skiaBitmap->getPixels(); bitmapSize = IntSize(skiaBitmap->width(), skiaBitmap->height()); } #elif PLATFORM(CG) Vector<uint8_t> tempVector; int rowBytes = 4 * dirtyRect.width(); tempVector.resize(rowBytes * dirtyRect.height()); memset(tempVector.data(), 0, tempVector.size()); RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB()); RetainPtr<CGContextRef> contextCG(AdoptCF, CGBitmapContextCreate(tempVector.data(), dirtyRect.width(), dirtyRect.height(), 8, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedLast)); CGContextTranslateCTM(contextCG.get(), 0, dirtyRect.height()); CGContextScaleCTM(contextCG.get(), 1, -1); GraphicsContext graphicsContext(contextCG.get()); // Translate the graphics context into the coordinate system of the dirty rect. graphicsContext.translate(-dirtyRect.x(), -dirtyRect.y()); m_owner->paintGraphicsLayerContents(graphicsContext, dirtyRect); pixels = tempVector.data(); bitmapSize = dirtyRect.size(); #else #error "Need to implement for your platform." #endif unsigned textureId = m_contentsTexture; if (!textureId) textureId = layerRenderer()->createLayerTexture(); if (pixels) updateTextureRect(pixels, bitmapSize, requiredTextureSize, dirtyRect, textureId); }
JSValue* functionRun(ExecState* exec, JSObject*, JSValue*, const ArgList& args) { StopWatch stopWatch; UString fileName = args[0]->toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); JSGlobalObject* globalObject = exec->dynamicGlobalObject(); stopWatch.start(); Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), fileName, 1, script.data()); stopWatch.stop(); return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS()); }
static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fileNames, bool prettyPrint, bool dump) { Vector<char> script; if (dump) CodeGenerator::setDumpsGeneratedCode(true); bool success = true; for (size_t i = 0; i < fileNames.size(); i++) { UString fileName = fileNames[i]; if (!fillBufferWithContentsOfFile(fileName, script)) return false; // fail early so we can catch missing files if (prettyPrint) prettyPrintScript(globalObject->globalExec(), fileName, script); else { Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), fileName, 1, script.data()); success = success && completion.complType() != Throw; if (dump) { if (success) printf("End: %s\n", completion.value()->toString(globalObject->globalExec()).ascii()); else printf("Exception: %s\n", completion.value()->toString(globalObject->globalExec()).ascii()); } } } return success; }
bool NetscapePlugin::initialize(const Parameters& parameters) { uint16_t mode = parameters.isFullFramePlugin ? NP_FULL : NP_EMBED; m_shouldUseManualLoader = parameters.shouldUseManualLoader; CString mimeTypeCString = parameters.mimeType.utf8(); ASSERT(parameters.names.size() == parameters.values.size()); Vector<CString> paramNames; Vector<CString> paramValues; for (size_t i = 0; i < parameters.names.size(); ++i) { String parameterName = parameters.names[i]; #if PLUGIN_ARCHITECTURE(MAC) if (m_pluginModule->pluginQuirks().contains(PluginQuirks::WantsLowercaseParameterNames)) parameterName = parameterName.convertToASCIILowercase(); #endif paramNames.append(parameterName.utf8()); paramValues.append(parameters.values[i].utf8()); } #if PLUGIN_ARCHITECTURE(X11) if (equalLettersIgnoringASCIICase(parameters.mimeType, "application/x-shockwave-flash")) { size_t wmodeIndex = parameters.names.find("wmode"); if (wmodeIndex != notFound) { // Transparent window mode is not supported by X11 backend. if (equalLettersIgnoringASCIICase(parameters.values[wmodeIndex], "transparent") || (m_pluginModule->pluginQuirks().contains(PluginQuirks::ForceFlashWindowlessMode) && equalLettersIgnoringASCIICase(parameters.values[wmodeIndex], "window"))) paramValues[wmodeIndex] = "opaque"; } else if (m_pluginModule->pluginQuirks().contains(PluginQuirks::ForceFlashWindowlessMode)) { paramNames.append("wmode"); paramValues.append("opaque"); } } else if (equalLettersIgnoringASCIICase(parameters.mimeType, "application/x-webkit-test-netscape")) { paramNames.append("windowedPlugin"); paramValues.append("false"); } #endif // The strings that these pointers point to are kept alive by paramNames and paramValues. Vector<const char*> names; Vector<const char*> values; for (size_t i = 0; i < paramNames.size(); ++i) { names.append(paramNames[i].data()); values.append(paramValues[i].data()); } #if PLUGIN_ARCHITECTURE(MAC) if (m_pluginModule->pluginQuirks().contains(PluginQuirks::MakeOpaqueUnlessTransparentSilverlightBackgroundAttributeExists)) { for (size_t i = 0; i < parameters.names.size(); ++i) { if (equalLettersIgnoringASCIICase(parameters.names[i], "background")) { setIsTransparent(isTransparentSilverlightBackgroundValue(parameters.values[i].convertToASCIILowercase())); break; } } } m_layerHostingMode = parameters.layerHostingMode; #endif platformPreInitialize(); NetscapePlugin* previousNPPNewPlugin = currentNPPNewPlugin; m_inNPPNew = true; currentNPPNewPlugin = this; NPError error = NPP_New(const_cast<char*>(mimeTypeCString.data()), mode, names.size(), const_cast<char**>(names.data()), const_cast<char**>(values.data()), 0); m_inNPPNew = false; currentNPPNewPlugin = previousNPPNewPlugin; if (error != NPERR_NO_ERROR) return false; m_isStarted = true; // FIXME: This is not correct in all cases. m_npWindow.type = NPWindowTypeDrawable; if (!platformPostInitialize()) { destroy(); return false; } // Load the src URL if needed. if (!parameters.shouldUseManualLoader && !parameters.url.isEmpty() && shouldLoadSrcURL()) loadURL("GET", parameters.url.string(), String(), HTTPHeaderMap(), Vector<uint8_t>(), false, 0); return true; }
void NPObjectMessageReceiver::invoke(const NPIdentifierData& methodNameData, const Vector<NPVariantData>& argumentsData, bool& returnValue, NPVariantData& resultData) { if (!m_npObject->_class->invoke) { returnValue = false; return; } Vector<NPVariant> arguments; for (size_t i = 0; i < argumentsData.size(); ++i) arguments.append(m_npRemoteObjectMap->npVariantDataToNPVariant(argumentsData[i], m_plugin)); NPVariant result; VOID_TO_NPVARIANT(result); PluginController::PluginDestructionProtector protector(m_plugin->controller()); returnValue = m_npObject->_class->invoke(m_npObject, methodNameData.createNPIdentifier(), arguments.data(), arguments.size(), &result); if (returnValue) { // Convert the NPVariant to an NPVariantData. resultData = m_npRemoteObjectMap->npVariantToNPVariantData(result, m_plugin); } // Release all arguments. for (size_t i = 0; i < argumentsData.size(); ++i) releaseNPVariantValue(&arguments[i]); // And release the result. releaseNPVariantValue(&result); }
static void runInteractive(GlobalObject* globalObject) { while (true) { #if HAVE(READLINE) && !RUNNING_FROM_XCODE char* line = readline(interactivePrompt); if (!line) break; if (line[0]) add_history(line); Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName)); free(line); #else printf("%s", interactivePrompt); Vector<char, 256> line; int c; while ((c = getchar()) != EOF) { // FIXME: Should we also break on \r? if (c == '\n') break; line.append(c); } if (line.isEmpty()) break; line.append('\0'); Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName)); #endif if (completion.complType() == Throw) printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii()); else printf("%s\n", completion.value().toString(globalObject->globalExec()).UTF8String().c_str()); globalObject->globalExec()->clearException(); } printf("\n"); }
bool PlatformCertificateInfo::decode(CoreIPC::ArgumentDecoder* decoder, PlatformCertificateInfo& c) { uint64_t length; if (!decoder->decode(length)) return false; if (length == std::numeric_limits<uint64_t>::max()) { // This is the no certificates case. return true; } for (size_t i = 0; i < length; ++i) { Vector<uint8_t> bytes; if (!decoder->decodeBytes(bytes)) { c.clearCertificateChain(); return false; } PCCERT_CONTEXT certificateContext = ::CertCreateCertificateContext(PKCS_7_ASN_ENCODING | X509_ASN_ENCODING, bytes.data(), bytes.size()); if (!certificateContext) { c.clearCertificateChain(); return false; } c.m_certificateChain.append(certificateContext); } return true; }
JSValue JSC_HOST_CALL functionLoad(ExecState* exec, JSObject* o, JSValue v, const ArgList& args) { UNUSED_PARAM(o); UNUSED_PARAM(v); UString fileName = args.at(0).toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); JSGlobalObject* globalObject = exec->lexicalGlobalObject(); Completion result = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName)); if (result.complType() == Throw) exec->setException(result.value()); return result.value(); }
static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, bool dump) { UString script; UString fileName; Vector<char> scriptBuffer; if (dump) BytecodeGenerator::setDumpsGeneratedCode(true); #if ENABLE(OPCODE_SAMPLING) Interpreter* interpreter = globalObject->globalData()->interpreter; interpreter->setSampler(new SamplingTool(interpreter)); interpreter->sampler()->setup(); #endif #if ENABLE(SAMPLING_FLAGS) SamplingFlags::start(); #endif bool success = true; for (size_t i = 0; i < scripts.size(); i++) { if (scripts[i].isFile) { fileName = scripts[i].argument; if (!fillBufferWithContentsOfFile(fileName, scriptBuffer)) return false; // fail early so we can catch missing files script = scriptBuffer.data(); } else { script = scripts[i].argument; fileName = "[Command Line]"; } #if ENABLE(SAMPLING_THREAD) SamplingThread::start(); #endif Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script, fileName)); success = success && completion.complType() != Throw; if (dump) { if (completion.complType() == Throw) printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii()); else printf("End: %s\n", completion.value().toString(globalObject->globalExec()).ascii()); } #if ENABLE(SAMPLING_THREAD) SamplingThread::stop(); #endif globalObject->globalExec()->clearException(); } #if ENABLE(SAMPLING_FLAGS) SamplingFlags::stop(); #endif #if ENABLE(OPCODE_SAMPLING) interpreter->sampler()->dump(globalObject->globalExec()); delete interpreter->sampler(); #endif #if ENABLE(SAMPLING_COUNTERS) AbstractSamplingCounter::dump(); #endif return success; }
JSValue JSC_HOST_CALL functionRun(ExecState* exec, JSObject*, JSValue, const ArgList& args) { StopWatch stopWatch; UString fileName = args.at(0).toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); JSGlobalObject* globalObject = exec->lexicalGlobalObject(); stopWatch.start(); evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName)); stopWatch.stop(); return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS()); }
PassRefPtr<FormData> FormData::create(const Vector<char>& vector) { RefPtr<FormData> result = create(); result->appendData(vector.data(), vector.size()); return result.release(); }
String FormData::flattenToString() const { Vector<char> bytes; flatten(bytes); return Latin1Encoding().decode(bytes.data(), bytes.size()); }
void UniscribeController::advance(unsigned offset, GlyphBuffer* glyphBuffer) { // FIXME: We really want to be using a newer version of Uniscribe that supports the new OpenType // functions. Those functions would allow us to turn off kerning and ligatures. Without being able // to do that, we will have buggy line breaking and metrics when simple and complex text are close // together (the complex code path will narrow the text because of kerning and ligatures and then // when bidi processing splits into multiple runs, the simple portions will get wider and cause us to // spill off the edge of a line). if (static_cast<int>(offset) > m_end) offset = m_end; int length = offset - m_currentCharacter; if (length <= 0) return; // Itemize the string. const UChar* cp = m_run.data16(m_currentCharacter); unsigned baseCharacter = m_currentCharacter; // We break up itemization of the string by fontData and (if needed) the use of small caps. // FIXME: It's inconsistent that we use logical order when itemizing, since this // does not match normal RTL. // FIXME: This function should decode surrogate pairs. Currently it makes little difference that // it does not because the font cache on Windows does not support non-BMP characters. Vector<UChar, 256> smallCapsBuffer; if (m_font.isSmallCaps()) smallCapsBuffer.resize(length); unsigned indexOfFontTransition = m_run.rtl() ? length - 1 : 0; const UChar* curr = m_run.rtl() ? cp + length - 1 : cp; const UChar* end = m_run.rtl() ? cp - 1 : cp + length; const SimpleFontData* fontData; const SimpleFontData* nextFontData = m_font.glyphDataForCharacter(*curr, false).fontData; UChar newC = 0; bool isSmallCaps; bool nextIsSmallCaps = m_font.isSmallCaps() && !(category(*curr) & (Mark_NonSpacing | Mark_Enclosing | Mark_SpacingCombining)) && (newC = toUpper(*curr)) != *curr; if (nextIsSmallCaps) smallCapsBuffer[curr - cp] = newC; while (true) { curr = m_run.rtl() ? curr - 1 : curr + 1; if (curr == end) break; fontData = nextFontData; isSmallCaps = nextIsSmallCaps; int index = curr - cp; UChar c = *curr; bool forceSmallCaps = isSmallCaps && (category(c) & (Mark_NonSpacing | Mark_Enclosing | Mark_SpacingCombining)); nextFontData = m_font.glyphDataForCharacter(*curr, false, forceSmallCaps ? SmallCapsVariant : AutoVariant).fontData; if (m_font.isSmallCaps()) { nextIsSmallCaps = forceSmallCaps || (newC = toUpper(c)) != c; if (nextIsSmallCaps) smallCapsBuffer[index] = forceSmallCaps ? c : newC; } if (m_fallbackFonts && nextFontData != fontData && fontData != m_font.primaryFont()) m_fallbackFonts->add(fontData); if (nextFontData != fontData || nextIsSmallCaps != isSmallCaps) { int itemStart = m_run.rtl() ? index + 1 : indexOfFontTransition; int itemLength = m_run.rtl() ? indexOfFontTransition - index : index - indexOfFontTransition; m_currentCharacter = baseCharacter + itemStart; itemizeShapeAndPlace((isSmallCaps ? smallCapsBuffer.data() : cp) + itemStart, itemLength, fontData, glyphBuffer); indexOfFontTransition = index; } } int itemLength = m_run.rtl() ? indexOfFontTransition + 1 : length - indexOfFontTransition; if (itemLength) { if (m_fallbackFonts && nextFontData != m_font.primaryFont()) m_fallbackFonts->add(nextFontData); int itemStart = m_run.rtl() ? 0 : indexOfFontTransition; m_currentCharacter = baseCharacter + itemStart; itemizeShapeAndPlace((nextIsSmallCaps ? smallCapsBuffer.data() : cp) + itemStart, itemLength, nextFontData, glyphBuffer); } m_currentCharacter = baseCharacter + length; }
void SharedBuffer::append(const Vector<char>& data) { append(data.data(), data.size()); }
bool NetscapePlugin::initialize(const Parameters& parameters) { uint16_t mode = parameters.isFullFramePlugin ? NP_FULL : NP_EMBED; m_shouldUseManualLoader = parameters.shouldUseManualLoader; CString mimeTypeCString = parameters.mimeType.utf8(); ASSERT(parameters.names.size() == parameters.values.size()); Vector<CString> paramNames; Vector<CString> paramValues; for (size_t i = 0; i < parameters.names.size(); ++i) { String parameterName = parameters.names[i]; #if PLUGIN_ARCHITECTURE(MAC) if (m_pluginModule->pluginQuirks().contains(PluginQuirks::WantsLowercaseParameterNames)) parameterName = parameterName.lower(); #endif paramNames.append(parameterName.utf8()); paramValues.append(parameters.values[i].utf8()); } // The strings that these pointers point to are kept alive by paramNames and paramValues. Vector<const char*> names; Vector<const char*> values; for (size_t i = 0; i < paramNames.size(); ++i) { names.append(paramNames[i].data()); values.append(paramValues[i].data()); } #if PLUGIN_ARCHITECTURE(MAC) if (m_pluginModule->pluginQuirks().contains(PluginQuirks::MakeTransparentIfBackgroundAttributeExists)) { for (size_t i = 0; i < parameters.names.size(); ++i) { if (equalIgnoringCase(parameters.names[i], "background")) { setIsTransparent(true); break; } } } m_layerHostingMode = parameters.layerHostingMode; #endif NetscapePlugin* previousNPPNewPlugin = currentNPPNewPlugin; m_inNPPNew = true; currentNPPNewPlugin = this; NPError error = NPP_New(const_cast<char*>(mimeTypeCString.data()), mode, names.size(), const_cast<char**>(names.data()), const_cast<char**>(values.data()), 0); m_inNPPNew = false; currentNPPNewPlugin = previousNPPNewPlugin; if (error != NPERR_NO_ERROR) return false; m_isStarted = true; // FIXME: This is not correct in all cases. m_npWindow.type = NPWindowTypeDrawable; if (!platformPostInitialize()) { destroy(); return false; } // Load the src URL if needed. if (!parameters.shouldUseManualLoader && !parameters.url.isEmpty() && shouldLoadSrcURL()) loadURL("GET", parameters.url.string(), String(), HTTPHeaderMap(), Vector<uint8_t>(), false, 0); return true; }
void PluginDatabase::loadPersistentMetadataCache() { if (!isPersistentMetadataCacheEnabled() || persistentMetadataCachePath().isEmpty()) return; PlatformFileHandle file; String absoluteCachePath = pathByAppendingComponent(persistentMetadataCachePath(), persistentPluginMetadataCacheFilename); file = openFile(absoluteCachePath, OpenForRead); if (!isHandleValid(file)) return; // Mark cache as loaded regardless of success or failure. If // there's error in the cache, we won't try to load it anymore. m_persistentMetadataCacheIsLoaded = true; Vector<char> fileContents; fillBufferWithContentsOfFile(file, fileContents); closeFile(file); if (fileContents.size() < 2 || fileContents.first() != schemaVersion || fileContents.last() != '\0') { LOG_ERROR("Unable to read plugin metadata cache: corrupt schema"); deleteFile(absoluteCachePath); return; } char* bufferPos = fileContents.data() + 1; char* end = fileContents.data() + fileContents.size(); PluginSet cachedPlugins; HashMap<String, time_t> cachedPluginPathsWithTimes; HashMap<String, RefPtr<PluginPackage> > cachedPluginsByPath; while (bufferPos < end) { String path; time_t lastModified; String name; String desc; String mimeDesc; if (!(readUTF8String(path, bufferPos, end) && readTime(lastModified, bufferPos, end) && readUTF8String(name, bufferPos, end) && readUTF8String(desc, bufferPos, end) && readUTF8String(mimeDesc, bufferPos, end))) { LOG_ERROR("Unable to read plugin metadata cache: corrupt data"); deleteFile(absoluteCachePath); return; } // Skip metadata that points to plugins from directories that // are not part of plugin directory list anymore. String pluginDirectoryName = directoryName(path); if (m_pluginDirectories.find(pluginDirectoryName) == WTF::notFound) continue; RefPtr<PluginPackage> package = PluginPackage::createPackageFromCache(path, lastModified, name, desc, mimeDesc); if (package && cachedPlugins.add(package).isNewEntry) { cachedPluginPathsWithTimes.add(package->path(), package->lastModified()); cachedPluginsByPath.add(package->path(), package); } } m_plugins.swap(cachedPlugins); m_pluginsByPath.swap(cachedPluginsByPath); m_pluginPathsWithTimes.swap(cachedPluginPathsWithTimes); }
static inline HTTPHeaderMap parseRFC822HeaderFields(const Vector<char>& buffer, unsigned length) { const char* bytes = buffer.data(); const char* eol; String lastKey; HTTPHeaderMap headerFields; // Loop ove rlines until we're past the header, or we can't find any more end-of-lines while ((eol = findEOL(bytes, length))) { const char* line = bytes; int lineLength = eol - bytes; // Move bytes to the character after the terminator as returned by findEOL. bytes = eol + 1; if ((*eol == '\r') && (*bytes == '\n')) bytes++; // Safe since findEOL won't return a spanning CRLF. length -= (bytes - line); if (lineLength == 0) // Blank line; we're at the end of the header break; else if (*line == ' ' || *line == '\t') { // Continuation of the previous header if (lastKey.isNull()) { // malformed header; ignore it and continue continue; } else { // Merge the continuation of the previous header String currentValue = headerFields.get(lastKey); String newValue(line, lineLength); headerFields.set(lastKey, currentValue + newValue); } } else { // Brand new header const char* colon; for (colon = line; *colon != ':' && colon != eol; colon++) { // empty loop } if (colon == eol) // malformed header; ignore it and continue continue; else { lastKey = capitalizeRFC822HeaderFieldName(String(line, colon - line)); String value; for (colon++; colon != eol; colon++) { if (*colon != ' ' && *colon != '\t') break; } if (colon == eol) value = ""; else value = String(colon, eol - colon); String oldValue = headerFields.get(lastKey); if (!oldValue.isNull()) { String tmp = oldValue; tmp += ", "; tmp += value; value = tmp; } headerFields.set(lastKey, value); } } } return headerFields; }
int main(int argc, char *argv[]){ Network yarp; //Port<Bottle> armPlan; //Port<Bottle> armPred; Port armPlan; Port armPred; armPlan.open("/randArm/plan"); armPred.open("/randArm/pred"); bool fwCvOn = 0; fwCvOn = Network::connect("/randArm/plan","/fwdConv:i"); fwCvOn *= Network::connect("/fwdConv:o","/randArm/pred"); if (!fwCvOn){ printf("Please run command:\n ./fwdConv --input /fwdConv:i --output /fwdConv:o"); return 1; } const gsl_rng_type *T; gsl_rng *r; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc(T); Property params; params.fromCommand(argc,argv); if (!params.check("robot")){ fprintf(stderr, "Please specify robot name"); fprintf(stderr, "e.g. --robot icub"); return -1; } std::string robotName = params.find("robot").asString().c_str(); std::string remotePorts = "/"; remotePorts += robotName; remotePorts += "/"; if (params.check("side")){ remotePorts += params.find("side").asString().c_str(); } else{ remotePorts += "left"; } remotePorts += "_arm"; std::string localPorts = "/randArm/cmd"; Property options; options.put("device", "remote_controlboard"); options.put("local", localPorts.c_str()); options.put("remote", remotePorts.c_str()); PolyDriver robotDevice(options); if (!robotDevice.isValid()){ printf("Device not available. Here are known devices: \n"); printf("%s", Drivers::factory().toString().c_str()); Network::fini(); return 1; } IPositionControl *pos; IEncoders *enc; bool ok; ok = robotDevice.view(pos); ok = ok && robotDevice.view(enc); if (!ok){ printf("Problems acquiring interfaces\n"); return 0; } int nj = 0; pos->getAxes(&nj); Vector encoders; Vector command; Vector commandCart; Vector tmp; encoders.resize(nj); tmp.resize(nj); command.resize(nj); commandCart.resize(nj); for (int i = 0; i < nj; i++) { tmp[i] = 25.0; } pos->setRefAccelerations(tmp.data()); for (int i = 0; i < nj; i++) { tmp[i] = 5.0; pos->setRefSpeed(i, tmp[i]); } command = 0; //set the arm joints to "middle" values command[0] = -45; command[1] = 45; command[2] = 0; command[3] = 45; pos->positionMove(command.data()); bool done = false; while (!done){ pos->checkMotionDone(&done); Time::delay(0.1); } while (true){ tmp = command; command[0] += 15*(2*gsl_rng_uniform(r)-1); command[1] += 15*(2*gsl_rng_uniform(r)-1); command[2] += 15*(2*gsl_rng_uniform(r)-1); command[3] += 15*(2*gsl_rng_uniform(r)-1); printf("%.1lf %.1lf %.1lf %.1lf\n", command[0], command[1], command[2], command[3]); //above 0 doesn't seem to be safe for joint 0 if (command[0] > 0 || command[0] < -90){ command[0] = tmp[0]; } if (command[1] > 160 || command[1] < -0){ command[1] = tmp[1]; } if (command[2] > 100 || command[2] < -35){ command[2] = tmp[2]; } if (command[3] > 100 || command[3] < 10){ command[3] = tmp[3]; } //use fwd kin to find end effector position Bottle plan, pred; for (int i = 0; i < nj; i++){ plan.add(command[i]); } armPlan.write(plan); armPred.read(pred); for (int i = 0; i < 3; i++){ commandCart[i] = pred.get(i).asDouble(); } double rad = sqrt(commandCart[0]*commandCart[0]+commandCart[1]*commandCart[1]); // safety radius back to 30 cm if (rad > 0.3){ pos->positionMove(command.data()); done = false; while(!done){ pos->checkMotionDone(&done); Time::delay(0.1); } } else{ printf("Self collision detected!\n"); } } robotDevice.close(); gsl_rng_free(r); return 0; }
void HTMLViewSourceDocument::addViewSourceToken(Token* token) { if (!m_current) createContainingTable(); if (token->tagName == textAtom) addText(token->text.get(), ""); else if (token->tagName == commentAtom) { if (token->beginTag) { m_current = addSpanWithClassName("webkit-html-comment"); addText(String("<!--") + token->text.get() + "-->", "webkit-html-comment"); } } else { // Handle the tag. String classNameStr = "webkit-html-tag"; m_current = addSpanWithClassName(classNameStr); String text = "<"; if (!token->beginTag) text += "/"; text += token->tagName; Vector<UChar>* guide = token->m_sourceInfo.get(); if (!guide || !guide->size()) text += ">"; addText(text, classNameStr); // Walk our guide string that tells us where attribute names/values should go. if (guide && guide->size()) { unsigned size = guide->size(); unsigned begin = 0; unsigned currAttr = 0; RefPtr<Attribute> attr = 0; for (unsigned i = 0; i < size; i++) { if (guide->at(i) == 'a' || guide->at(i) == 'x' || guide->at(i) == 'v') { // Add in the string. addText(String(static_cast<UChar*>(guide->data()) + begin, i - begin), classNameStr); begin = i + 1; if (guide->at(i) == 'a') { if (token->attrs && currAttr < token->attrs->length()) attr = token->attrs->attributeItem(currAttr++); else attr = 0; } if (attr) { if (guide->at(i) == 'a') { String name = attr->name().toString(); m_current = addSpanWithClassName("webkit-html-attribute-name"); addText(name, "webkit-html-attribute-name"); if (m_current != m_tbody) m_current = static_cast<Element*>(m_current->parent()); } else { const String& value = attr->value().string(); // Compare ignoring case since HTMLTokenizer doesn't // lower names when passing in tokens to // HTMLViewSourceDocument. if (equalIgnoringCase(token->tagName, "base") && equalIgnoringCase(attr->name().localName(), "href")) { // Catch the href attribute in the base element. // It will be used for rendering anchors created // by addLink() below. setBaseElementURL(KURL(url(), value)); } // FIXME: XML could use namespace prefixes and confuse us. if (equalIgnoringCase(attr->name().localName(), "src") || equalIgnoringCase(attr->name().localName(), "href")) m_current = addLink(value, equalIgnoringCase(token->tagName, "a")); else m_current = addSpanWithClassName("webkit-html-attribute-value"); addText(value, "webkit-html-attribute-value"); if (m_current != m_tbody) m_current = static_cast<Element*>(m_current->parent()); } } } } // Add in any string that might be left. if (begin < size) addText(String(static_cast<UChar*>(guide->data()) + begin, size - begin), classNameStr); // Add in the end tag. addText(">", classNameStr); } m_current = m_td; } }
void TextureMapperLayer::sortByZOrder(Vector<TextureMapperLayer* >& array) { qsort(array.data(), array.size(), sizeof(TextureMapperLayer*), compareGraphicsLayersZValue); }
JSValue* functionLoad(ExecState* exec, JSObject*, JSValue*, const ArgList& args) { UString fileName = args[0]->toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); JSGlobalObject* globalObject = exec->dynamicGlobalObject(); Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), fileName, 1, script.data()); return jsUndefined(); }
bool convertWOFFToSfnt(SharedBuffer* woff, Vector<char>& sfnt) { ASSERT_ARG(sfnt, sfnt.isEmpty()); size_t offset = 0; // Read the WOFF header. uint32_t signature; if (!readUInt32(woff, offset, signature) || signature != woffSignature) { ASSERT_NOT_REACHED(); return false; } uint32_t flavor; if (!readUInt32(woff, offset, flavor)) return false; uint32_t length; if (!readUInt32(woff, offset, length) || length != woff->size()) return false; uint16_t numTables; if (!readUInt16(woff, offset, numTables)) return false; if (!numTables || numTables > 0x0fff) return false; uint16_t reserved; if (!readUInt16(woff, offset, reserved) || reserved) return false; uint32_t totalSfntSize; if (!readUInt32(woff, offset, totalSfntSize)) return false; if (woff->size() - offset < sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t)) return false; offset += sizeof(uint16_t); // majorVersion offset += sizeof(uint16_t); // minorVersion offset += sizeof(uint32_t); // metaOffset offset += sizeof(uint32_t); // metaLength offset += sizeof(uint32_t); // metaOrigLength offset += sizeof(uint32_t); // privOffset offset += sizeof(uint32_t); // privLength // Check if the WOFF can supply as many tables as it claims it has. if (woff->size() - offset < numTables * 5 * sizeof(uint32_t)) return false; // Write the sfnt offset subtable. uint16_t entrySelector = 0; uint16_t searchRange = 1; while (searchRange < numTables >> 1) { entrySelector++; searchRange <<= 1; } searchRange <<= 4; uint16_t rangeShift = (numTables << 4) - searchRange; if (!writeUInt32(sfnt, flavor) || !writeUInt16(sfnt, numTables) || !writeUInt16(sfnt, searchRange) || !writeUInt16(sfnt, entrySelector) || !writeUInt16(sfnt, rangeShift)) return false; if (sfnt.size() > totalSfntSize) return false; if (totalSfntSize - sfnt.size() < numTables * 4 * sizeof(uint32_t)) return false; size_t sfntTableDirectoryCursor = sfnt.size(); sfnt.grow(sfnt.size() + numTables * 4 * sizeof(uint32_t)); // Process tables. for (uint16_t i = 0; i < numTables; ++i) { // Read a WOFF table directory entry. uint32_t tableTag; if (!readUInt32(woff, offset, tableTag)) return false; uint32_t tableOffset; if (!readUInt32(woff, offset, tableOffset)) return false; uint32_t tableCompLength; if (!readUInt32(woff, offset, tableCompLength)) return false; if (tableOffset > woff->size() || tableCompLength > woff->size() - tableOffset) return false; uint32_t tableOrigLength; if (!readUInt32(woff, offset, tableOrigLength) || tableCompLength > tableOrigLength) return false; if (tableOrigLength > totalSfntSize || sfnt.size() > totalSfntSize - tableOrigLength) return false; uint32_t tableOrigChecksum; if (!readUInt32(woff, offset, tableOrigChecksum)) return false; // Write an sfnt table directory entry. uint32_t* sfntTableDirectoryPtr = reinterpret_cast<uint32_t*>(sfnt.data() + sfntTableDirectoryCursor); *sfntTableDirectoryPtr++ = htonl(tableTag); *sfntTableDirectoryPtr++ = htonl(tableOrigChecksum); *sfntTableDirectoryPtr++ = htonl(sfnt.size()); *sfntTableDirectoryPtr++ = htonl(tableOrigLength); sfntTableDirectoryCursor += 4 * sizeof(uint32_t); if (tableCompLength == tableOrigLength) { // The table is not compressed. if (!sfnt.tryAppend(woff->data() + tableOffset, tableCompLength)) return false; } else { uLongf destLen = tableOrigLength; if (!sfnt.tryReserveCapacity(sfnt.size() + tableOrigLength)) return false; Bytef* dest = reinterpret_cast<Bytef*>(sfnt.end()); sfnt.grow(sfnt.size() + tableOrigLength); if (uncompress(dest, &destLen, reinterpret_cast<const Bytef*>(woff->data() + tableOffset), tableCompLength) != Z_OK) return false; if (destLen != tableOrigLength) return false; } // Pad to a multiple of 4 bytes. while (sfnt.size() % 4) sfnt.append(0); } return sfnt.size() == totalSfntSize; }
static void runInteractive(GlobalObject* globalObject) { while (true) { #if HAVE(READLINE) char* line = readline(interactivePrompt); if (!line) break; if (line[0]) add_history(line); Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), interpreterName, 1, line); free(line); #else puts(interactivePrompt); Vector<char, 256> line; int c; while ((c = getchar()) != EOF) { // FIXME: Should we also break on \r? if (c == '\n') break; line.append(c); } line.append('\0'); Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), interpreterName, 1, line.data()); #endif if (completion.isValueCompletion()) printf("%s\n", completion.value()->toString(globalObject->globalExec()).UTF8String().c_str()); } printf("\n"); }
Region::Shape Region::Shape::shapeOperation(const Shape& shape1, const Shape& shape2) { static_assert(!(!Operation::shouldAddRemainingSegmentsFromSpan1 && Operation::shouldAddRemainingSegmentsFromSpan2), "invalid segment combination"); static_assert(!(!Operation::shouldAddRemainingSpansFromShape1 && Operation::shouldAddRemainingSpansFromShape2), "invalid span combination"); size_t segmentsCapacity = shape1.segmentsSize() + shape2.segmentsSize(); size_t spansCapacity = shape1.spansSize() + shape2.spansSize(); Shape result(segmentsCapacity, spansCapacity); if (Operation::trySimpleOperation(shape1, shape2, result)) return result; SpanIterator spans1 = shape1.spansBegin(); SpanIterator spans1End = shape1.spansEnd(); SpanIterator spans2 = shape2.spansBegin(); SpanIterator spans2End = shape2.spansEnd(); SegmentIterator segments1 = 0; SegmentIterator segments1End = 0; SegmentIterator segments2 = 0; SegmentIterator segments2End = 0; Vector<int, 32> segments; segments.reserveCapacity(std::max(shape1.segmentsSize(), shape2.segmentsSize())); // Iterate over all spans. while (spans1 != spans1End && spans2 != spans2End) { int y = 0; int test = spans1->y - spans2->y; if (test <= 0) { y = spans1->y; segments1 = shape1.segmentsBegin(spans1); segments1End = shape1.segmentsEnd(spans1); ++spans1; } if (test >= 0) { y = spans2->y; segments2 = shape2.segmentsBegin(spans2); segments2End = shape2.segmentsEnd(spans2); ++spans2; } int flag = 0; int oldFlag = 0; SegmentIterator s1 = segments1; SegmentIterator s2 = segments2; // Clear vector without dropping capacity. segments.resize(0); ASSERT(segments.capacity()); // Now iterate over the segments in each span and construct a new vector of segments. while (s1 != segments1End && s2 != segments2End) { int test = *s1 - *s2; int x; if (test <= 0) { x = *s1; flag = flag ^ 1; ++s1; } if (test >= 0) { x = *s2; flag = flag ^ 2; ++s2; } if (flag == Operation::opCode || oldFlag == Operation::opCode) segments.append(x); oldFlag = flag; } // Add any remaining segments. if (Operation::shouldAddRemainingSegmentsFromSpan1 && s1 != segments1End) segments.appendRange(s1, segments1End); else if (Operation::shouldAddRemainingSegmentsFromSpan2 && s2 != segments2End) segments.appendRange(s2, segments2End); // Add the span. if (!segments.isEmpty() || !result.isEmpty()) result.appendSpan(y, segments.data(), segments.data() + segments.size()); } // Add any remaining spans. if (Operation::shouldAddRemainingSpansFromShape1 && spans1 != spans1End) result.appendSpans(shape1, spans1, spans1End); else if (Operation::shouldAddRemainingSpansFromShape2 && spans2 != spans2End) result.appendSpans(shape2, spans2, spans2End); result.trimCapacities(); return result; }
static bool startHttp(ResourceHandle* handle) { ASSERT(handle); SoupSession* session = handle->defaultSession(); ensureSessionIsInitialized(session); ResourceHandleInternal* d = handle->getInternal(); ResourceRequest request(handle->firstRequest()); KURL url(request.url()); url.removeFragmentIdentifier(); request.setURL(url); d->m_msg = request.toSoupMessage(); if (!d->m_msg) return false; if (!handle->shouldContentSniff()) soup_message_disable_feature(d->m_msg, SOUP_TYPE_CONTENT_SNIFFER); g_signal_connect(d->m_msg, "restarted", G_CALLBACK(restartedCallback), handle); g_signal_connect(d->m_msg, "got-headers", G_CALLBACK(gotHeadersCallback), handle); g_signal_connect(d->m_msg, "content-sniffed", G_CALLBACK(contentSniffedCallback), handle); g_signal_connect(d->m_msg, "got-chunk", G_CALLBACK(gotChunkCallback), handle); #ifdef HAVE_LIBSOUP_2_29_90 String firstPartyString = request.firstPartyForCookies().string(); if (!firstPartyString.isEmpty()) { GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data())); soup_message_set_first_party(d->m_msg, firstParty.get()); } #endif g_object_set_data(G_OBJECT(d->m_msg), "resourceHandle", reinterpret_cast<void*>(handle)); FormData* httpBody = d->m_firstRequest.httpBody(); if (httpBody && !httpBody->isEmpty()) { size_t numElements = httpBody->elements().size(); // handle the most common case (i.e. no file upload) if (numElements < 2) { Vector<char> body; httpBody->flatten(body); soup_message_set_request(d->m_msg, d->m_firstRequest.httpContentType().utf8().data(), SOUP_MEMORY_COPY, body.data(), body.size()); } else { /* * we have more than one element to upload, and some may * be (big) files, which we will want to mmap instead of * copying into memory; TODO: support upload of non-local * (think sftp://) files by using GIO? */ soup_message_body_set_accumulate(d->m_msg->request_body, FALSE); for (size_t i = 0; i < numElements; i++) { const FormDataElement& element = httpBody->elements()[i]; if (element.m_type == FormDataElement::data) soup_message_body_append(d->m_msg->request_body, SOUP_MEMORY_TEMPORARY, element.m_data.data(), element.m_data.size()); else { /* * mapping for uploaded files code inspired by technique used in * libsoup's simple-httpd test */ GError* error = 0; CString fileName = fileSystemRepresentation(element.m_filename); GMappedFile* fileMapping = g_mapped_file_new(fileName.data(), false, &error); if (error) { g_error_free(error); g_signal_handlers_disconnect_matched(d->m_msg, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, handle); g_object_unref(d->m_msg); d->m_msg = 0; return false; } SoupBuffer* soupBuffer = soup_buffer_new_with_owner(g_mapped_file_get_contents(fileMapping), g_mapped_file_get_length(fileMapping), fileMapping, #if GLIB_CHECK_VERSION(2, 21, 3) reinterpret_cast<GDestroyNotify>(g_mapped_file_unref)); #else reinterpret_cast<GDestroyNotify>(g_mapped_file_free)); #endif soup_message_body_append_buffer(d->m_msg->request_body, soupBuffer); soup_buffer_free(soupBuffer); } } } }
static leveldb::Slice makeSlice(const Vector<char>& value) { return leveldb::Slice(value.data(), value.size()); }