Page* ChromeClientBlackBerry::createWindow(Frame*, const FrameLoadRequest& request, const WindowFeatures& features)
{
PageGroupLoadDeferrer deferrer(m_webPage->d->m_page, true);
TimerBase::fireTimersInNestedEventLoop();
int x = features.xSet ? features.x : 0;
int y = features.ySet ? features.y : 0;
int width = features.widthSet? features.width : -1;
int height = features.heightSet ? features.height : -1;
unsigned flags = 0;
if (features.menuBarVisible)
flags |= Olympia::WebKit::WebPageClient::FlagWindowHasMenuBar;
if (features.statusBarVisible)
flags |= Olympia::WebKit::WebPageClient::FlagWindowHasStatusBar;
if (features.toolBarVisible)
flags |= Olympia::WebKit::WebPageClient::FlagWindowHasToolBar;
if (features.locationBarVisible)
flags |= Olympia::WebKit::WebPageClient::FlagWindowHasLocationBar;
if (features.scrollbarsVisible)
flags |= Olympia::WebKit::WebPageClient::FlagWindowHasScrollBar;
if (features.resizable)
flags |= Olympia::WebKit::WebPageClient::FlagWindowIsResizable;
if (features.fullscreen)
flags |= Olympia::WebKit::WebPageClient::FlagWindowIsFullScreen;
if (features.dialog)
flags |= Olympia::WebKit::WebPageClient::FlagWindowIsDialog;
Olympia::WebKit::WebPage* webPage = m_webPage->client()->createWindow(x, y, width, height, flags);
if (!webPage)
return 0;
Page* newPage = webPage->d->m_page;
if (!request.resourceRequest().isNull())
newPage->mainFrame()->loader()->load(request.resourceRequest(), false);
return newPage;
}
QImage Score::createThumbnail()
{
LayoutMode mode = layoutMode();
setLayoutMode(LayoutMode::PAGE);
doLayout();
Page* page = pages().at(0);
QRectF fr = page->abbox();
qreal mag = 256.0 / qMax(fr.width(), fr.height());
int w = int(fr.width() * mag);
int h = int(fr.height() * mag);
QImage pm(w, h, QImage::Format_ARGB32_Premultiplied);
int dpm = lrint(DPMM * 1000.0);
pm.setDotsPerMeterX(dpm);
pm.setDotsPerMeterY(dpm);
pm.fill(0xffffffff);
double pr = MScore::pixelRatio;
MScore::pixelRatio = 1.0;
QPainter p(&pm);
p.setRenderHint(QPainter::Antialiasing, true);
p.setRenderHint(QPainter::TextAntialiasing, true);
p.scale(mag, mag);
print(&p, 0);
p.end();
MScore::pixelRatio = pr;
if (layoutMode() != mode) {
setLayoutMode(mode);
doLayout();
}
return pm;
}
Heap::Page *Heap::WorkPage(int k) // get a new workpage with empty blocks
{
LLOG("AllocK - next work not available " << k << " empty: " << (void *)empty[k]);
Page *page = empty[k]; // hot empty page of the same klass
empty[k] = NULL;
if(!page) { // try to reacquire pages freed remotely
LLOG("AllocK - trying FreeRemote");
SmallFreeRemote();
if(work[k]->freelist) { // partially free page found
LLOG("AllocK - work available after FreeRemote " << k);
return work[k];
}
page = empty[k]; // hot empty page
empty[k] = NULL;
}
if(!page)
for(int i = 0; i < NKLASS; i++) // Try hot empty page of different klass
if(empty[i]) {
LLOG("AllocK - free page available for reformatting " << k);
page = empty[i];
empty[i] = NULL;
page->Format(k); // reformat the page for the required klass
break;
}
if(!page) { // Attempt to find page in global storage of free pages
Mutex::Lock __(mutex);
aux.SmallFreeRemoteRaw();
if(aux.work[k]->next != aux.work[k]) { // Try page of the same klass first
page = aux.work[k]->next;
page->Unlink();
LLOG("AllocK - adopting aux page " << k << " page: " << (void *)page << ", free " << (void *)page->freelist);
}
if(!page && aux.empty[k]) { // Try hot empty page of the same klass
page = aux.empty[k];
aux.empty[k] = page->next;
LLOG("AllocK - empty aux page available of the same format " << k << " page: " << (void *)page << ", free " << (void *)page->freelist);
}
if(!page)
for(int i = 0; i < NKLASS; i++) // Finally try to to find hot page of different klass
if(aux.empty[i]) {
page = aux.empty[i];
aux.empty[i] = page->next;
page->Format(k);
LLOG("AllocK - empty aux page available for reformatting " << k << " page: " << (void *)page << ", free " << (void *)page->freelist);
break;
}
if(!page) { // No free memory was found, ask system for the new page
page = (Page *)AllocRaw4KB(Ksz(k));
LLOG("AllocK - allocated new system page " << (void *)page << " " << k);
page->Format(k);
}
page->heap = this;
}
page->Link(work[k]);
ASSERT(page->klass == k);
return page;
}
void DocumentStyleSheetCollection::updateInjectedStyleSheetCache() const
{
if (m_injectedStyleSheetCacheValid)
return;
m_injectedStyleSheetCacheValid = true;
m_injectedUserStyleSheets.clear();
m_injectedAuthorStyleSheets.clear();
Page* owningPage = m_document->page();
if (!owningPage)
return;
const PageGroup& pageGroup = owningPage->group();
const UserStyleSheetMap* sheetsMap = pageGroup.userStyleSheets();
if (!sheetsMap)
return;
UserStyleSheetMap::const_iterator end = sheetsMap->end();
for (UserStyleSheetMap::const_iterator it = sheetsMap->begin(); it != end; ++it) {
const UserStyleSheetVector* sheets = it->value.get();
for (unsigned i = 0; i < sheets->size(); ++i) {
const UserStyleSheet* sheet = sheets->at(i).get();
if (sheet->injectedFrames() == InjectInTopFrameOnly && m_document->ownerElement())
continue;
if (!UserContentURLPattern::matchesPatterns(m_document->url(), sheet->whitelist(), sheet->blacklist()))
continue;
RefPtr<CSSStyleSheet> groupSheet = CSSStyleSheet::createInline(const_cast<Document*>(m_document), sheet->url());
bool isUserStyleSheet = sheet->level() == UserStyleUserLevel;
if (isUserStyleSheet)
m_injectedUserStyleSheets.append(groupSheet);
else
m_injectedAuthorStyleSheets.append(groupSheet);
groupSheet->contents()->setIsUserStyleSheet(isUserStyleSheet);
groupSheet->contents()->parseString(sheet->source());
}
}
}
void File::addpage(Page &page,long pageno)
{
int freespace = 0;
int record_num = 0;
if(pageno >= page_num_ ){
for(long i = page_num_; i < pageno; ++i){
fseek(fp_,(i+1)*page_size_ + 2*sizeof(long) - 2*sizeof(int),SEEK_SET);
fwrite(&record_num,sizeof(int),1,fp_);
fwrite(&freespace,sizeof(int),1,fp_);
}
page_num_ = pageno + 1;
}
char *bits = new (std::nothrow) char[page_size_];
if(bits == NULL){
fprintf(stderr,"no enough memory!\n");
exit(-1);
}
memset(bits,0,page_size_);
page.set_page_size(page_size_);
page.tobinary(bits);
fseek(fp_,0,SEEK_SET);
fwrite(&page_num_,sizeof(long),1,fp_);
fwrite(&page_size_,sizeof(long),1,fp_);
fseek(fp_,pageno*page_size_+2*sizeof(long),SEEK_SET);
fwrite(bits,sizeof(char),page_size_,fp_);
delete [] bits;
}
const Status HeapFileScan::getRandomRecord(const RID & rid,
Record & rec)
{
// Solution Starts
Page* page;
Status status;
if ((curPageNo > 0) &&
(rid.pageNo != curPageNo))
{
// there is a page pinned which is not the desired page, unpin it
status = bufMgr->unPinPage(file, curPageNo,
dirtyFlag);
if (status != OK) return status;
curPageNo = -1;
curPage = NULL;
}
if (curPageNo < 1) { // no current page?
// get prepared to read the desired page
curPageNo = rid.pageNo; // extract page # from rid
dirtyFlag = false;
// read desired page
status = bufMgr->readPage(file, curPageNo,
curPage);
if (status != OK) return status;
}
page = curPage;
status = page->getRecord(rid, rec);
curRec.pageNo = rid.pageNo;
curRec.slotNo = rid.slotNo;
return status;
// Solution Ends
}
const Vector<RefPtr<CSSStyleSheet> >* DocumentStyleSheetCollection::pageGroupUserSheets() const
{
if (m_pageGroupUserSheetCacheValid)
return m_pageGroupUserSheets.get();
m_pageGroupUserSheetCacheValid = true;
Page* owningPage = m_document->page();
if (!owningPage)
return 0;
const PageGroup& pageGroup = owningPage->group();
const UserStyleSheetMap* sheetsMap = pageGroup.userStyleSheets();
if (!sheetsMap)
return 0;
UserStyleSheetMap::const_iterator end = sheetsMap->end();
for (UserStyleSheetMap::const_iterator it = sheetsMap->begin(); it != end; ++it) {
const UserStyleSheetVector* sheets = it->second.get();
for (unsigned i = 0; i < sheets->size(); ++i) {
const UserStyleSheet* sheet = sheets->at(i).get();
if (sheet->injectedFrames() == InjectInTopFrameOnly && m_document->ownerElement())
continue;
if (!UserContentURLPattern::matchesPatterns(m_document->url(), sheet->whitelist(), sheet->blacklist()))
continue;
RefPtr<CSSStyleSheet> groupSheet = CSSStyleSheet::createInline(const_cast<Document*>(m_document), sheet->url());
if (!m_pageGroupUserSheets)
m_pageGroupUserSheets = adoptPtr(new Vector<RefPtr<CSSStyleSheet> >);
m_pageGroupUserSheets->append(groupSheet);
groupSheet->contents()->setIsUserStyleSheet(sheet->level() == UserStyleUserLevel);
groupSheet->contents()->parseString(sheet->source());
}
}
return m_pageGroupUserSheets.get();
}
void RenderVideo::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
MediaPlayer* mediaPlayer = mediaElement()->player();
bool displayingPoster = videoElement()->shouldDisplayPosterImage();
Page* page = 0;
if (Frame* frame = this->frame())
page = frame->page();
if (!displayingPoster) {
if (!mediaPlayer) {
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantUnpaintedObject(this, visualOverflowRect());
return;
}
updatePlayer();
}
LayoutRect rect = videoBox();
if (rect.isEmpty()) {
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantUnpaintedObject(this, visualOverflowRect());
return;
}
rect.moveBy(paintOffset);
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantRepaintedObject(this, rect);
if (displayingPoster)
paintIntoRect(paintInfo.context, rect);
else if (document()->view() && document()->view()->paintBehavior() & PaintBehaviorFlattenCompositingLayers)
mediaPlayer->paintCurrentFrameInContext(paintInfo.context, pixelSnappedIntRect(rect));
else
mediaPlayer->paint(paintInfo.context, pixelSnappedIntRect(rect));
}
void Console::profileEnd(const JSC::UString& title, ScriptCallStack* callStack)
{
Page* page = this->page();
if (!page)
return;
#if ENABLE(INSPECTOR)
if (!page->inspectorController()->profilerEnabled())
return;
#endif
RefPtr<JSC::Profile> profile = JSC::Profiler::profiler()->stopProfiling(callStack->state(), title);
if (!profile)
return;
m_profiles.append(profile);
#if ENABLE(INSPECTOR)
if (Page* page = this->page()) {
const ScriptCallFrame& lastCaller = callStack->at(0);
page->inspectorController()->addProfile(profile, lastCaller.lineNumber(), lastCaller.sourceURL());
}
#endif
}
void WindowProxy::setDOMWindow(AbstractDOMWindow* newDOMWindow)
{
ASSERT(newDOMWindow);
if (m_jsWindowProxies.isEmpty())
return;
ASSERT(m_frame);
JSLockHolder lock(commonVM());
for (auto& windowProxy : jsWindowProxiesAsVector()) {
if (&windowProxy->wrapped() == newDOMWindow)
continue;
windowProxy->setWindow(*newDOMWindow);
ScriptController* scriptController = nullptr;
Page* page = nullptr;
if (is<Frame>(*m_frame)) {
auto& frame = downcast<Frame>(*m_frame);
scriptController = &frame.script();
page = frame.page();
}
// ScriptController's m_cacheableBindingRootObject persists between page navigations
// so needs to know about the new JSDOMWindow.
if (auto* cacheableBindingRootObject = scriptController ? scriptController->existingCacheableBindingRootObject() : nullptr)
cacheableBindingRootObject->updateGlobalObject(windowProxy->window());
windowProxy->attachDebugger(page ? page->debugger() : nullptr);
if (page)
windowProxy->window()->setProfileGroup(page->group().identifier());
windowProxy->window()->setConsoleClient(page ? &page->console() : nullptr);
}
}
Operator::GetNextResultT ConsumeOp::getNext(unsigned short threadid)
{
CtInt val = 0;
dbgassert(vec.at(threadid) != NULL);
Page* out = vec[threadid];
GetNextResultT result;
assertaddresslocal(&val);
const int tupw = nextOp->getOutSchema().getTupleSize();
do {
result = nextOp->getNext(threadid);
dbgassert(result.first != Error);
Page* in = result.second;
Page::Iterator it = in->createIterator();
void* tuple;
while ( (tuple = it.next()) )
{
CtInt* casttuple = (CtInt*) tuple;
for (int i=0; i<(tupw/4); ++i)
{
val ^= casttuple[i];
}
}
} while(result.first == Operator::Ready);
assertaddresslocal(&val);
void* dest = out->allocateTuple();
schema.writeData(dest, 0, &val);
return make_pair(Finished, out);
}
void Console::timeEnd(ExecState* exec, const ArgList& args)
{
UString title;
if (args.size() >= 1)
title = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
if (title.isNull())
return;
Page* page = this->page();
if (!page)
return;
double elapsed;
if (!page->inspectorController()->stopTiming(title, elapsed))
return;
String message = String(title) + String::format(": %.0fms", elapsed);
KURL url;
unsigned lineNumber;
retrieveLastCaller(exec, url, lineNumber);
page->inspectorController()->addMessageToConsole(JSMessageSource, LogMessageLevel, message, lineNumber, url.string());
}
bool Shelfscreen::readBook(QString book)
{
for (int loopc=0; loopc<elements.size(); loopc++)
{
ShelfElement & se = elements[loopc];
if(se.book->getFullName() == book)
{
se.book->open();
settings->setCurrentBook(se.book->getFullName());
settings->setCurrentPage(0);
BookDevice * bd = new BookDevice(se.book);
bd->open(QIODevice::ReadOnly);
Parser * parser = new Parser(bd, se.book);
Page * page = new Page(se.book, parser);
top_level->addWidget(page);
page->setPage(0);
top_level->setCurrentWidget(page);
current_page = page;
return true;
}
}
return false;
}
int File::getpage(Page &page,long pageno)
{
if(pageno >= page_num_){
fprintf(stderr,"you tried to read past the end of the file\n");
return -1;
}
char *bits = new (std::nothrow) char[page_size_];
if(bits == NULL){
fprintf(stderr,"no enough memory!\n");
exit(-1);
}
fseek(fp_,pageno*page_size_+2*sizeof(long),SEEK_SET);
fread(bits,sizeof(char),page_size_,fp_);
page.set_page_size(page_size_);
page.frombinary(bits);
delete [] bits;
return 0;
}
void Console::addMessage(MessageType type, MessageLevel level, PassRefPtr<ScriptArguments> prpArguments, PassRefPtr<ScriptCallStack> prpCallStack, bool acceptNoArguments)
{
RefPtr<ScriptArguments> arguments = prpArguments;
RefPtr<ScriptCallStack> callStack = prpCallStack;
Page* page = this->page();
if (!page)
return;
const ScriptCallFrame& lastCaller = callStack->at(0);
if (!acceptNoArguments && !arguments->argumentCount())
return;
if (Console::shouldPrintExceptions()) {
printSourceURLAndLine(lastCaller.sourceURL(), 0);
printMessageSourceAndLevelPrefix(JSMessageSource, level);
for (unsigned i = 0; i < arguments->argumentCount(); ++i) {
String argAsString;
if (arguments->argumentAt(i).getString(arguments->globalState(), argAsString))
printf(" %s", argAsString.utf8().data());
}
printf("\n");
}
String message;
for (unsigned i = 0; i < arguments->argumentCount(); ++i) {
message.append(arguments->argumentAt(i).toString(arguments->globalState()));
if (i < arguments->argumentCount() - 1)
message.append(' ');
}
page->chrome()->client()->addMessageToConsole(JSMessageSource, type, level, message, lastCaller.lineNumber(), lastCaller.sourceURL(), prpCallStack);
InspectorInstrumentation::addMessageToConsole(page, JSMessageSource, type, level, message, arguments, callStack);
}
void HistoryController::updateBackForwardListClippedAtTarget(bool doClip)
{
// In the case of saving state about a page with frames, we store a tree of items that mirrors the frame tree.
// The item that was the target of the user's navigation is designated as the "targetItem".
// When this function is called with doClip=true we're able to create the whole tree except for the target's children,
// which will be loaded in the future. That part of the tree will be filled out as the child loads are committed.
Page* page = m_frame->page();
if (!page)
return;
if (m_frame->loader()->documentLoader()->urlForHistory().isEmpty())
return;
Frame* mainFrame = page->mainFrame();
ASSERT(mainFrame);
FrameLoader* frameLoader = mainFrame->loader();
frameLoader->checkDidPerformFirstNavigation();
RefPtr<HistoryItem> topItem = frameLoader->history()->createItemTree(m_frame, doClip);
LOG(BackForward, "WebCoreBackForward - Adding backforward item %p for frame %s", topItem.get(), m_frame->loader()->documentLoader()->url().string().ascii().data());
page->backForward()->addItem(topItem.release());
}
// Main funnel for navigating to a previous location (back/forward, non-search snap-back)
// This includes recursion to handle loading into framesets properly
void HistoryController::goToItem(HistoryItem* targetItem, FrameLoadType type)
{
ASSERT(!m_frame->tree()->parent());
// shouldGoToHistoryItem is a private delegate method. This is needed to fix:
// <rdar://problem/3951283> can view pages from the back/forward cache that should be disallowed by Parental Controls
// Ultimately, history item navigations should go through the policy delegate. That's covered in:
// <rdar://problem/3979539> back/forward cache navigations should consult policy delegate
Page* page = m_frame->page();
if (!page)
return;
if (!m_frame->loader()->client()->shouldGoToHistoryItem(targetItem))
return;
// Set the BF cursor before commit, which lets the user quickly click back/forward again.
// - plus, it only makes sense for the top level of the operation through the frametree,
// as opposed to happening for some/one of the page commits that might happen soon
BackForwardList* bfList = page->backForwardList();
HistoryItem* currentItem = bfList->currentItem();
bfList->goToItem(targetItem);
Settings* settings = m_frame->settings();
page->setGlobalHistoryItem((!settings || settings->privateBrowsingEnabled()) ? 0 : targetItem);
recursiveGoToItem(targetItem, currentItem, type);
}
String Console::lastWMLErrorMessage() const
{
#if ENABLE(INSPECTOR)
Page* page = this->page();
if (!page)
return String();
const Vector<ConsoleMessage*>& consoleMessages = page->inspectorController()->consoleMessages();
if (consoleMessages.isEmpty())
return String();
Vector<ConsoleMessage*>::const_iterator it = consoleMessages.begin();
const Vector<ConsoleMessage*>::const_iterator end = consoleMessages.end();
for (; it != end; ++it) {
ConsoleMessage* message = *it;
if (message->source() != WMLMessageSource)
continue;
return message->message();
}
#endif
return String();
}
void Console::addMessage(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& url, unsigned lineNumber, PassRefPtr<ScriptCallStack> callStack, unsigned long requestIdentifier)
{
if (muteCount && source != ConsoleAPIMessageSource)
return;
Page* page = this->page();
if (!page)
return;
page->chrome()->client()->addMessageToConsole(source, type, level, message, lineNumber, url);
if (callStack)
InspectorInstrumentation::addMessageToConsole(page, source, type, level, message, callStack, requestIdentifier);
else
InspectorInstrumentation::addMessageToConsole(page, source, type, level, message, url, lineNumber, requestIdentifier);
if (!Console::shouldPrintExceptions())
return;
printSourceURLAndLine(url, lineNumber);
printMessageSourceAndLevelPrefix(source, level);
printf(" %s\n", message.utf8().data());
}
bool Geolocation::startUpdating(GeoNotifier* notifier)
{
#if ENABLE(CLIENT_BASED_GEOLOCATION)
// FIXME: Pass options to client.
if (!isAllowed()) {
m_startRequestPermissionNotifier = notifier;
requestPermission();
return true;
}
if (!m_frame)
return false;
Page* page = m_frame->page();
if (!page)
return false;
page->geolocationController()->addObserver(this);
return true;
#else
return m_service->startUpdating(notifier->m_options.get());
#endif
}
PageGroupLoadDeferrer::PageGroupLoadDeferrer(Page* page, bool deferSelf)
{
const HashSet<Page*>& pages = page->group().pages();
HashSet<Page*>::const_iterator end = pages.end();
for (HashSet<Page*>::const_iterator it = pages.begin(); it != end; ++it) {
Page* otherPage = *it;
if ((deferSelf || otherPage != page)) {
if (!otherPage->defersLoading()) {
m_deferredFrames.append(otherPage->mainFrame());
// This code is not logically part of load deferring, but we do not want JS code executed beneath modal
// windows or sheets, which is exactly when PageGroupLoadDeferrer is used.
for (Frame* frame = otherPage->mainFrame(); frame; frame = frame->tree()->traverseNext())
frame->document()->suspendScheduledTasks(ActiveDOMObject::WillDeferLoading);
}
}
}
size_t count = m_deferredFrames.size();
for (size_t i = 0; i < count; ++i)
if (Page* page = m_deferredFrames[i]->page())
page->setDefersLoading(true);
}
void defaultPivotTest() {
ham_key_t key = {};
ham_record_t rec = {};
char buffer[80] = {0};
for (int i = 11; i >= 0; i--) {
*(int *)&buffer[0] = i;
key.data = &buffer[0];
key.size = sizeof(buffer);
REQUIRE(0 == ham_db_insert(m_db, 0, &key, &rec, 0));
}
/* now verify that the index has 3 pages - root and two pages in
* level 1 - both are 50% full
*
* the first page is the old root page, which became an index
* page after the split
*/
Page *page;
PBtreeNode *node;
REQUIRE((page = fetch_page(m_environ->get_page_size() * 1)));
REQUIRE((Page::kTypeBindex & page->get_type()));
node = PBtreeNode::from_page(page);
REQUIRE(7 == node->get_count());
REQUIRE((page = fetch_page(m_environ->get_page_size() * 2)));
REQUIRE((Page::kTypeBindex & page->get_type()));
node = PBtreeNode::from_page(page);
REQUIRE(5 == node->get_count());
REQUIRE((page = fetch_page(m_environ->get_page_size() * 3)));
REQUIRE((Page::kTypeBindex & page->get_type()));
node = PBtreeNode::from_page(page);
REQUIRE(1 == node->get_count());
}
void checkPageAlloc()
{
cerr << fmtTitle("alloc", '.') << endl;
typedef BlockPage<Policy> Page;
Page* page = createPage<Policy>();
auto& log = Page::log;
array<void*, Page::NumBlocks> blocks;
for (size_t i = 0; i < Page::NumBlocks; ++i) {
locklessCheck(page->hasFreeBlock(), log);
void* block = page->alloc();
fillBlock<Policy>(block, i);
page->free(blocks[i] = block);
if (!i) {
locklessCheckEq(
uintptr_t(page) + (Page::MetadataBlocks * Policy::BlockSize),
uintptr_t(blocks[0]),
log);
}
else {
locklessCheckGt(blocks[i], page, log);
locklessCheckLe(
uintptr_t(blocks[i]) + Policy::BlockSize,
uintptr_t(page) + Policy::PageSize,
log);
locklessCheckEq(
uintptr_t(blocks[i-1]) + Policy::BlockSize,
uintptr_t(blocks[i]),
log);
}
locklessCheckEq(page, Page::pageForBlock(blocks[i]), log);
}
for (size_t iteration = 0; iteration < 2; ++iteration) {
for (size_t i = 0; i < Page::NumBlocks; ++i)
locklessCheckEq(blocks[i], page->alloc(), log);
for (size_t i = 0; i < Page::NumBlocks; ++i)
page->free(blocks[i]);
}
locklessCheck(page->kill(), log);
}
bool BarProp::visible() const
{
if (!m_frame)
return false;
Page* page = m_frame->page();
if (!page)
return false;
switch (m_type) {
case Locationbar:
case Personalbar:
case Toolbar:
return page->chrome().toolbarsVisible();
case Menubar:
return page->chrome().menubarVisible();
case Scrollbars:
return page->chrome().scrollbarsVisible();
case Statusbar:
return page->chrome().statusbarVisible();
}
ASSERT_NOT_REACHED();
return false;
}
void Page::updatePage(Page &newPage){
webpageP->mainFrame()->setHtml(newPage.getHtml()); // This takes 50 ms!
int prevs = mDOMNodes.size(); //temp
mDOMNodes.clear();//We migth need to wait here?
setDOMNodes(webpageP->mainFrame()->documentElement());
//Now all the DOMNodes are updated to the new one
mBentoTree->mHeight=newPage.mBentoTree->mHeight;
mBentoTree->mNumNodes=newPage.mBentoTree->mNumNodes;
mColor=newPage.mColor;
mPageID=newPage.mPageID;
mURL=newPage.mURL;
ComputedStyleList=newPage.ComputedStyleList;
copyPage(mBentoTree->mRootBlock,newPage.mBentoTree->mRootBlock);
}
void CachedPage::restore(Page& page)
{
ASSERT(m_cachedMainFrame);
ASSERT(m_cachedMainFrame->view()->frame().isMainFrame());
ASSERT(!page.subframeCount());
m_cachedMainFrame->open();
// Restore the focus appearance for the focused element.
// FIXME: Right now we don't support pages w/ frames in the b/f cache. This may need to be tweaked when we add support for that.
Document* focusedDocument = page.focusController().focusedOrMainFrame().document();
if (Element* element = focusedDocument->focusedElement()) {
#if PLATFORM(IOS)
// We don't want focused nodes changing scroll position when restoring from the cache
// as it can cause ugly jumps before we manage to restore the cached position.
page.mainFrame().selection().suppressScrolling();
#endif
element->updateFocusAppearance(true);
#if PLATFORM(IOS)
page.mainFrame().selection().restoreScrolling();
#endif
}
if (m_needStyleRecalcForVisitedLinks) {
for (Frame* frame = &page.mainFrame(); frame; frame = frame->tree().traverseNext())
frame->document()->visitedLinkState().invalidateStyleForAllLinks();
}
#if USE(ACCELERATED_COMPOSITING)
if (m_needsDeviceScaleChanged) {
page.mainFrame().deviceOrPageScaleFactorChanged();
}
#endif
if (m_needsFullStyleRecalc)
page.setNeedsRecalcStyleInAllFrames();
#if ENABLE(VIDEO_TRACK)
if (m_needsCaptionPreferencesChanged)
page.captionPreferencesChanged();
#endif
clear();
}
TEST(Page, GetByteAtOffset) {
stringstream input_stream;
input_stream << '\0' << '1' << '\n' << ' ';
Page* page = Page::read_from_input(input_stream);
ASSERT_EQ(4, page->size());
EXPECT_EQ('\0', page->get_byte_at_offset(0));
EXPECT_EQ('1', page->get_byte_at_offset(1));
EXPECT_EQ('\n', page->get_byte_at_offset(2));
EXPECT_EQ(' ', page->get_byte_at_offset(3));
}
void pagesManager::megrePagesToFile( int begin, int end, FILE* tempFptr ) {
//get last Page for output
Page *lastPage = &pages[ end + 1 ];
lastPage->clearPage();
//keep track of pages
int *offsets = new int[end - begin + 1];
memset( offsets, 0, ( end - begin + 1 ) * 4 );
while ( true ) { //when the pages have not been read
int min = -1; //find the minimize of the first entry of pages
bool first = true;
for ( int i = begin ; i <= end; i++ ) {
//printPage( pages[i].getData() );
if ( offsets[ i - begin ] < pages[i].getOffset() ) { //if this page is not been read at end
if ( first ) { //init the min
first = false;
min = i;
} else if( compare( pages[i].getData() + offsets[i-begin],
pages[min].getData() + offsets[min-begin] ) < 0 ) {
min = i;
}
}
} //for loop end, min save the value of the pageIndex of min
while ( !lastPage->insertDataToPage( pages[min].getData() + offsets[min-begin], 8 ) ) { //insert the min value to the output page
//if insert fail
//write page to file
lastPage->writePageToFile( tempFptr );
lastPage->clearPage();
}
offsets[ min - begin ] += 8; //next entry
//exam if all pages has been read
int i;
for ( i = begin ; i <= end; i++ ) {
if ( offsets[ i - begin ] < pages[i].getOffset() ) { //if a page is not at the end
break;
}
}
if ( i == end + 1 ) { //if all pages has been read, break the loop
break;
}
}
//write remain page
lastPage->writePageToFile( tempFptr );
clearPages( begin, end + 1 );
}
void test12() {
PageId firstPageID = 1;
const bool notDirty = 0;
const bool isDirty = 1;
Page *testPage;
// Test unPinPage sets dirty bit to true
bufMgr->readPage(file1ptr, firstPageID, testPage);
sprintf((char*)tmpbuf, "Testing unPinPage");
const RecordId& rid = testPage->insertRecord(tmpbuf);
bufMgr->unPinPage(file1ptr, firstPageID, isDirty);
bufMgr->flushFile(file1ptr);
bufMgr->readPage(file1ptr, firstPageID, testPage);
if(strncmp(testPage->getRecord(rid).c_str(), tmpbuf , strlen(tmpbuf)) != 0)
{
PRINT_ERROR("ERROR :: UnPinPage did not set dirty bit correctly");
}
testPage->deleteRecord(rid);
bufMgr->unPinPage(file1ptr, firstPageID, notDirty);
// Test unPinPage does not set dirty bit to false
bufMgr->readPage(file1ptr, firstPageID, testPage);
sprintf((char*)tmpbuf, "Testing unPinPage");
const RecordId& rid2 = testPage->insertRecord(tmpbuf); // rid2 == rid since we're the only users?
bufMgr->unPinPage(file1ptr, firstPageID, isDirty);
bufMgr->readPage(file1ptr, firstPageID, testPage);
bufMgr->unPinPage(file1ptr, firstPageID, notDirty);
bufMgr->flushFile(file1ptr);
bufMgr->readPage(file1ptr, firstPageID, testPage);
if(strncmp(testPage->getRecord(rid2).c_str(), tmpbuf , strlen(tmpbuf)) != 0)
{
PRINT_ERROR("ERROR :: UnPinPage did not set dirty bit correctly");
}
testPage->deleteRecord(rid2);
bufMgr->unPinPage(file1ptr, firstPageID, notDirty);
// Flush file to attain guaranteed post test state.
bufMgr->flushFile(file1ptr);
std::cout << "Test 12 passed" << "\n";
}
void parseMaxTextFiles( Page& page, const Sequence<String>& fileLocations )
{
IPIterator<String>* it = fileLocations.positions();
while ( it->hasNext() )
{
IPosition<String>* p = it->next();
{
const String& location = p->getElement();
const char* _location = location.getChars();
File file( _location );
// const char* _absolute = file.getPath().getAbsolute().getChars();
if ( file.exists() )
{
FileInputStream in( file );
page.parse( in );
}
}
delete p;
}
delete it;
}
