// -----------------------------------------------------------------------------
// RDRMRightsClient::
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RDRMRightsClient::IsInCache( const TDesC8& aID,
TBool& aInCache )
{
DRMLOG( _L( "RDRMRightsClient::IsInCache" ) );
TPckg< TBool > inCache( aInCache );
return SendReceive( DRMEngine::EIsInCache,
TIpcArgs( &aID, NULL, &inCache ) );
}
CachedResource::~CachedResource()
{
ASSERT(!inCache());
ASSERT(!m_deleted);
#ifndef NDEBUG
m_deleted = true;
#endif
if (m_docLoader)
m_docLoader->removeCachedResource(this);
}
void CachedResource::setEncodedSize(unsigned size)
{
if (size == m_encodedSize)
return;
long long delta = static_cast<long long>(size) - m_encodedSize;
// The object must be moved to a different queue, since its size has been changed.
// Remove before updating m_encodedSize, so we find the resource in the correct LRU list.
if (allowsCaching() && inCache())
MemoryCache::singleton().removeFromLRUList(*this);
m_encodedSize = size;
if (allowsCaching() && inCache()) {
auto& memoryCache = MemoryCache::singleton();
memoryCache.insertInLRUList(*this);
memoryCache.adjustSize(hasClients(), delta);
}
}
// -----------------------------------------------------------------------------
// RDRMRightsClient::
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RDRMRightsClient::IsInCache( const TDesC8& aID,
const TTime& aTime,
TBool& aInCache )
{
DRMLOG( _L( "RDRMRightsClient::IsInCache" ) );
TPckgC< TTime > timePckg( aTime );
TPckg< TBool > inCache( aInCache );
return SendReceive( DRMEngine::EIsInCache,
TIpcArgs( &aID, &timePckg, &inCache ) );
}
void CachedResource::didAccessDecodedData(double timeStamp)
{
m_lastDecodedAccessTime = timeStamp;
if (inCache()) {
if (m_inLiveDecodedResourcesList) {
memoryCache()->removeFromLiveDecodedResourcesList(this);
memoryCache()->insertInLiveDecodedResourcesList(this);
}
memoryCache()->prune();
}
}
void CachedResource::didAccessDecodedData(double timeStamp)
{
m_lastDecodedAccessTime = timeStamp;
if (allowsCaching() && inCache()) {
auto& memoryCache = MemoryCache::singleton();
if (memoryCache.inLiveDecodedResourcesList(*this)) {
memoryCache.removeFromLiveDecodedResourcesList(*this);
memoryCache.insertInLiveDecodedResourcesList(*this);
}
memoryCache.pruneSoon();
}
}
bool CachedResource::deleteIfPossible()
{
if (canDelete()) {
if (!inCache()) {
InspectorInstrumentation::willDestroyCachedResource(*this);
delete this;
return true;
}
if (m_data)
m_data->hintMemoryNotNeededSoon();
}
return false;
}
void CachedResource::setDecodedSize(unsigned size)
{
if (size == m_decodedSize)
return;
long long delta = static_cast<long long>(size) - m_decodedSize;
// The object must be moved to a different queue, since its size has been changed.
// Remove before updating m_decodedSize, so we find the resource in the correct LRU list.
if (allowsCaching() && inCache())
MemoryCache::singleton().removeFromLRUList(*this);
m_decodedSize = size;
if (allowsCaching() && inCache()) {
auto& memoryCache = MemoryCache::singleton();
// Now insert into the new LRU list.
memoryCache.insertInLRUList(*this);
// Insert into or remove from the live decoded list if necessary.
// When inserting into the LiveDecodedResourcesList it is possible
// that the m_lastDecodedAccessTime is still zero or smaller than
// the m_lastDecodedAccessTime of the current list head. This is a
// violation of the invariant that the list is to be kept sorted
// by access time. The weakening of the invariant does not pose
// a problem. For more details please see: https://bugs.webkit.org/show_bug.cgi?id=30209
bool inLiveDecodedResourcesList = memoryCache.inLiveDecodedResourcesList(*this);
if (m_decodedSize && !inLiveDecodedResourcesList && hasClients())
memoryCache.insertInLiveDecodedResourcesList(*this);
else if (!m_decodedSize && inLiveDecodedResourcesList)
memoryCache.removeFromLiveDecodedResourcesList(*this);
// Update the cache's size totals.
memoryCache.adjustSize(hasClients(), delta);
}
}
CachedResource::~CachedResource()
{
ASSERT(!m_resourceToRevalidate); // Should be true because canDelete() checks this.
ASSERT(canDelete());
ASSERT(!inCache());
ASSERT(!m_deleted);
ASSERT(url().isNull() || memoryCache()->resourceForRequest(resourceRequest(), sessionID()) != this);
#ifndef NDEBUG
m_deleted = true;
cachedResourceLeakCounter.decrement();
#endif
if (m_owningCachedResourceLoader)
m_owningCachedResourceLoader->removeCachedResource(this);
}
void CachedResource::switchClientsToRevalidatedResource()
{
ASSERT(m_resourceToRevalidate);
ASSERT(m_resourceToRevalidate->inCache());
ASSERT(!inCache());
LOG(ResourceLoading, "CachedResource %p switchClientsToRevalidatedResource %p", this, m_resourceToRevalidate);
m_switchingClientsToRevalidatedResource = true;
HashSet<CachedResourceHandleBase*>::iterator end = m_handlesToRevalidate.end();
for (HashSet<CachedResourceHandleBase*>::iterator it = m_handlesToRevalidate.begin(); it != end; ++it) {
CachedResourceHandleBase* handle = *it;
handle->m_resource = m_resourceToRevalidate;
m_resourceToRevalidate->registerHandle(handle);
--m_handleCount;
}
ASSERT(!m_handleCount);
m_handlesToRevalidate.clear();
Vector<CachedResourceClient*> clientsToMove;
HashCountedSet<CachedResourceClient*>::iterator end2 = m_clients.end();
for (HashCountedSet<CachedResourceClient*>::iterator it = m_clients.begin(); it != end2; ++it) {
CachedResourceClient* client = it->key;
unsigned count = it->value;
while (count) {
clientsToMove.append(client);
--count;
}
}
unsigned moveCount = clientsToMove.size();
for (unsigned n = 0; n < moveCount; ++n)
removeClient(clientsToMove[n]);
ASSERT(m_clients.isEmpty());
for (unsigned n = 0; n < moveCount; ++n)
m_resourceToRevalidate->addClientToSet(clientsToMove[n]);
for (unsigned n = 0; n < moveCount; ++n) {
// Calling didAddClient may do anything, including trying to cancel revalidation.
// Assert that it didn't succeed.
ASSERT(m_resourceToRevalidate);
// Calling didAddClient for a client may end up removing another client. In that case it won't be in the set anymore.
if (m_resourceToRevalidate->m_clients.contains(clientsToMove[n]))
m_resourceToRevalidate->didAddClient(clientsToMove[n]);
}
m_switchingClientsToRevalidatedResource = false;
}
void CachedResource::switchClientsToRevalidatedResource()
{
ASSERT(m_resourceToRevalidate);
ASSERT(m_resourceToRevalidate->inCache());
ASSERT(!inCache());
LOG(ResourceLoading, "CachedResource %p switchClientsToRevalidatedResource %p", this, m_resourceToRevalidate);
m_switchingClientsToRevalidatedResource = true;
for (auto& handle : m_handlesToRevalidate) {
handle->m_resource = m_resourceToRevalidate;
m_resourceToRevalidate->registerHandle(handle);
--m_handleCount;
}
ASSERT(!m_handleCount);
m_handlesToRevalidate.clear();
Vector<CachedResourceClient*> clientsToMove;
for (auto& entry : m_clients) {
CachedResourceClient* client = entry.key;
unsigned count = entry.value;
while (count) {
clientsToMove.append(client);
--count;
}
}
for (auto& client : clientsToMove)
removeClient(*client);
ASSERT(m_clients.isEmpty());
for (auto& client : clientsToMove)
m_resourceToRevalidate->addClientToSet(*client);
for (auto& client : clientsToMove) {
// Calling didAddClient may do anything, including trying to cancel revalidation.
// Assert that it didn't succeed.
ASSERT(m_resourceToRevalidate);
// Calling didAddClient for a client may end up removing another client. In that case it won't be in the set anymore.
if (m_resourceToRevalidate->m_clients.contains(client))
m_resourceToRevalidate->didAddClient(*client);
}
m_switchingClientsToRevalidatedResource = false;
}
void CachedResource::removeClient(CachedResourceClient& client)
{
auto callback = m_clientsAwaitingCallback.take(&client);
if (callback) {
ASSERT(!m_clients.contains(&client));
callback->cancel();
callback = nullptr;
} else {
ASSERT(m_clients.contains(&client));
m_clients.remove(&client);
didRemoveClient(client);
}
if (deleteIfPossible()) {
// `this` object is dead here.
return;
}
if (hasClients())
return;
auto& memoryCache = MemoryCache::singleton();
if (allowsCaching() && inCache()) {
memoryCache.removeFromLiveResourcesSize(*this);
memoryCache.removeFromLiveDecodedResourcesList(*this);
}
if (!m_switchingClientsToRevalidatedResource)
allClientsRemoved();
destroyDecodedDataIfNeeded();
if (!allowsCaching())
return;
if (response().cacheControlContainsNoStore() && url().protocolIs("https")) {
// RFC2616 14.9.2:
// "no-store: ... MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible"
// "... History buffers MAY store such responses as part of their normal operation."
// We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
memoryCache.remove(*this);
}
memoryCache.pruneSoon();
}
void CachedImage::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
m_data = data;
createImage();
bool sizeAvailable = false;
// Have the image update its data from its internal buffer.
// It will not do anything now, but will delay decoding until
// queried for info (like size or specific image frames).
sizeAvailable = m_image->setData(m_data, allDataReceived);
// Go ahead and tell our observers to try to draw if we have either
// received all the data or the size is known. Each chunk from the
// network causes observers to repaint, which will force that chunk
// to decode.
if (sizeAvailable || allDataReceived) {
size_t maxDecodedImageSize = maximumDecodedImageSize();
IntSize s = imageSize(1.0f);
size_t estimatedDecodedImageSize = s.width() * s.height() * 4; // no overflow check
if (m_image->isNull() || (maxDecodedImageSize > 0 && estimatedDecodedImageSize > maxDecodedImageSize)) {
error();
if (inCache())
cache()->remove(this);
return;
}
// It would be nice to only redraw the decoded band of the image, but with the current design
// (decoding delayed until painting) that seems hard.
notifyObservers();
if (m_image)
setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
}
if (allDataReceived) {
m_loading = false;
checkNotify();
}
}
/**
* Add object to cache
*/
int CacheManager::add(CacheObject *obj, const std::string &filename) {
assert(m_initialised == true);
assert(System::instance()->getFileHandler() != NULL);
std::string c_path = System::instance()->getFileHandler()->getUserDataPath()
+ CACHE_PATH;
// Check if object is already in cache
if (inCache(filename)) {
fprintf(stderr, "Object already cached.\n");
return 1;
}
// Get new cache name
std::string name = c_path + "objectXXXXXX";
// Convert to character array for mktemp function
char cache_name[name.size()];
memcpy(cache_name, name.c_str(), name.size());
#if(0)
// TODO Re-think this method so it is safe
// Currently disable as it is not used and generated warnings.
// Generate unique unused filename
if (!mktemp(cache_name)) {
fprintf(stderr, "Error generating cache name.\n");
return 1;
}
#endif
// Save object
if (obj->save(cache_name)) {
fprintf(stderr, "Error saving cache object.\n");
return 1;
}
// Add record to cache
m_cache.setItem(KEY_CACHE, filename, cache_name);
return 0;
}
void CachedImage::finishLoading(SharedBuffer* data)
{
m_data = data;
if (!m_image && data)
createImage();
if (m_image)
m_image->setData(data, true);
if (!m_image || m_image->isNull()) {
// Image decoding failed; the image data is malformed.
error(errorOccurred() ? status() : DecodeError);
if (inCache())
MemoryCache::singleton().remove(*this);
return;
}
notifyObservers();
if (m_image)
setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
CachedResource::finishLoading(data);
}
int webPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: loading((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 1: isLoading((*reinterpret_cast< QPixmap(*)>(_a[1]))); break;
case 2: titleChanged((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 3: pageChanged((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;
case 4: showSources((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 5: speedDial(); break;
case 6: needPrint((*reinterpret_cast< QPrinter*(*)>(_a[1]))); break;
case 7: openTab((*reinterpret_cast< webPage*(*)>(_a[1]))); break;
case 8: setFullScreen((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 9: startLoading(); break;
case 10: finishLoading((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 11: changeTitle((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 12: changeUrl((*reinterpret_cast< QUrl(*)>(_a[1]))); break;
case 13: goToHome(); break;
case 14: loadUrl(); break;
case 15: loadUrl((*reinterpret_cast< QUrl(*)>(_a[1]))); break;
case 16: loadUrl((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 17: addToBookMark(); break;
case 18: downloadFile((*reinterpret_cast< const QNetworkRequest(*)>(_a[1]))); break;
case 19: downloadFile((*reinterpret_cast< QNetworkReply*(*)>(_a[1]))); break;
case 20: loadBookMark(); break;
case 21: showBookMark(); break;
case 22: sources(); break;
case 23: defineHome(); break;
case 24: findNext(); break;
case 25: findPrevious(); break;
case 26: print(); break;
case 27: createNewPage((*reinterpret_cast< WebView*(*)>(_a[1]))); break;
case 28: createNewPage(); break;
case 29: updateIcon(); break;
case 30: copy(); break;
case 31: authentification((*reinterpret_cast< QNetworkReply*(*)>(_a[1])),(*reinterpret_cast< QAuthenticator*(*)>(_a[2]))); break;
case 32: inspectPage(); break;
case 33: goToDial(); break;
case 34: updateUrlIcon((*reinterpret_cast< QPixmap(*)>(_a[1]))); break;
case 35: updateBookMark(); break;
case 36: updateOptions(); break;
case 37: showBar(); break;
case 38: showPage(); break;
case 39: showDial(); break;
case 40: inCache(); break;
case 41: showConsole(); break;
case 42: zoomIn(); break;
case 43: zoomOut(); break;
case 44: restoreZoom(); break;
case 45: savePage(); break;
case 46: back(); break;
case 47: forward(); break;
default: ;
}
_id -= 48;
}
return _id;
}
void CachedResource::ref(CachedResourceClient *c)
{
if (!referenced() && inCache())
cache()->addToLiveResourcesSize(this);
m_clients.add(c);
}
