feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlDesigner: Add move only trace token

Browse Source 
It is quite hard to define always an end to a trace. A move only
token can do that. The drawback is that the token gets bigger but only
compile them for an avtivated category.

Change-Id: I88b47c5b47e4129b1cd402e89251b45fa126111c
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>
This commit is contained in:
Marco Bubke
2023-10-13 22:06:05 +02:00
committed by Tim Jenssen
parent 3d8c740705
commit 11bf705e26
26 changed files with 588 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/libs/nanotrace/nanotracehr.cpp
View File

@@ -24,14 +24,14 @@ void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, st
{ {
out << R"({"ph":")" << event.type << R"(","name":")" << event.name << R"(","cat":")" out << R"({"ph":")" << event.type << R"(","name":")" << event.name << R"(","cat":")"
<< event.category << R"(","ts":")" << event.category << R"(","ts":")"
<< static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":")" << static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":)"
<< processId << R"(","tid":")" << threadId << R"(")"; << processId << R"(,"tid":)" << threadId;
if (event.type == 'X') if (event.type == 'X')
out << R"(,"dur":)" << static_cast<double>(event.duration.count()) / 1000; out << R"(,"dur":)" << static_cast<double>(event.duration.count()) / 1000;
if (event.id != 0) if (event.id != 0)
out << R"(,"id":)" << event.id; out << R"(,"id":")" << event.id << R"(")";
if (event.arguments.size()) if (event.arguments.size())
out << R"(,"args":)" << event.arguments; out << R"(,"args":)" << event.arguments;
@@ -45,9 +45,9 @@ void writeMetaEvent(TraceFile<true> *file, std::string_view key, std::string_vie
auto &out = file->out; auto &out = file->out;
if (out.is_open()) { if (out.is_open()) {
file->out << R"({"name":")" << key << R"(","ph":"M", "pid":")" file->out << R"({"name":")" << key << R"(","ph":"M", "pid":)"
<< QCoreApplication::applicationPid() << R"(","tid":")" << QCoreApplication::applicationPid() << R"(,"tid":)"
<< std::this_thread::get_id() << R"(","args":{"name":")" << value << R"("}})" << std::this_thread::get_id() << R"(,"args":{"name":")" << value << R"("}})"
<< ",\n"; << ",\n";
} }
} }
@@ -194,6 +194,6 @@ void EventQueue<TraceEvent, std::true_type>::flush()
} }
} }
template class NANOTRACE_EXPORT EventQueue<StringViewTraceEvent, std::true_type>; template class EventQueue<StringViewTraceEvent, std::true_type>;
template class NANOTRACE_EXPORT EventQueue<StringTraceEvent, std::true_type>; template class EventQueue<StringTraceEvent, std::true_type>;
} // namespace NanotraceHR } // namespace NanotraceHR

170
src/libs/nanotrace/nanotracehr.h
View File

@@ -58,6 +58,7 @@ constexpr TracerLiteral operator""_t(const char *text, size_t size)
} // namespace Literals } // namespace Literals
using namespace Literals; using namespace Literals;
template<typename String> template<typename String>
struct TraceEvent struct TraceEvent
{ {
@@ -142,6 +143,7 @@ public:
TraceFile &operator=(TraceFile &&) = delete; TraceFile &operator=(TraceFile &&) = delete;
~TraceFile() { finalizeFile(*this); } ~TraceFile() { finalizeFile(*this); }
std::string filePath; std::string filePath;
std::mutex fileMutex; std::mutex fileMutex;
std::future<void> processing; std::future<void> processing;
@@ -257,43 +259,108 @@ TraceEvent &getTraceEvent(EnabledEventQueue<TraceEvent> &eventQueue)
return eventQueue.currentEvents[eventQueue.eventsIndex++]; return eventQueue.currentEvents[eventQueue.eventsIndex++];
} }
template<bool enabled> template<typename Category, bool enabled>
class Token class Token
{ {
public: public:
using IsActive = std::false_type; using IsActive = std::false_type;
using ArgumentType = typename Category::ArgumentType;
constexpr std::size_t operator*() const { return 0; } Token() {}
~Token() {}
constexpr Token(const Token &) = delete;
constexpr Token &operator=(const Token &) = delete;
constexpr Token(Token &&other) noexcept = default;
constexpr Token &operator=(Token &&other) noexcept = default;
constexpr explicit operator bool() const { return false; } constexpr explicit operator bool() const { return false; }
static constexpr bool isActive() { return false; } static constexpr bool isActive() { return false; }
Token begin(ArgumentType) { return Token{}; }
void tick(ArgumentType) {}
void end() {}
}; };
template<typename TraceEvent, bool enabled> template<typename TraceEvent, bool enabled>
class Category; class Category;
template<> template<typename Category>
class Token<true> class Token<Category, true>
{ {
friend Category<StringViewTraceEvent, true>; Token(std::string_view name, std::size_t id, Category &category)
friend Category<StringTraceEvent, true>; : m_name{name}
, m_id{id}
Token(std::size_t id) , m_category{&category}
: m_id{id}
{} {}
public: public:
using IsActive = std::true_type; using IsActive = std::true_type;
using StringType = typename Category::StringType;
using ArgumentType = typename Category::ArgumentType;
constexpr std::size_t operator*() const { return m_id; } friend Category;
Token() = default;
Token(const Token &) = delete;
Token &operator=(const Token &) = delete;
Token(Token &&other) noexcept
: m_name{other.m_name}
, m_id{std::exchange(other.m_id, 0)}
, m_category{std::exchange(other.m_category, nullptr)}
{}
Token &operator=(Token &&other) noexcept
{
if (&other != this) {
m_name = other.m_name;
m_id = std::exchange(other.m_id, 0);
m_category = std::exchange(other.m_category, nullptr);
}
return *this;
}
~Token() { end(); }
constexpr explicit operator bool() const { return m_id; } constexpr explicit operator bool() const { return m_id; }
static constexpr bool isActive() { return true; } static constexpr bool isActive() { return true; }
Token begin(ArgumentType name)
{
if (m_id)
m_category->beginAsynchronous(m_id, name);
return Token{m_name, m_id, *m_category};
}
void tick(ArgumentType name)
{
if (m_id)
m_category->tickAsynchronous(m_id, name);
}
void end()
{
if (m_id)
m_category->endAsynchronous(m_id, m_name);
m_id = 0;
}
private: private:
std::size_t m_id; StringType m_name;
std::size_t m_id = 0;
Category *m_category = nullptr;
}; };
template<typename TraceEvent, bool enabled> template<typename TraceEvent, bool enabled>
@@ -302,16 +369,15 @@ class Category
public: public:
using IsActive = std::false_type; using IsActive = std::false_type;
using ArgumentType = typename TraceEvent::ArgumentType; using ArgumentType = typename TraceEvent::ArgumentType;
using TokenType = Token<Category, false>;
Category(ArgumentType, EventQueue<TraceEvent, std::true_type> &) {} Category(ArgumentType, EventQueue<TraceEvent, std::true_type> &) {}
Category(ArgumentType, EventQueue<TraceEvent, std::false_type> &) {} Category(ArgumentType, EventQueue<TraceEvent, std::false_type> &) {}
Token<false> beginAsynchronous(ArgumentType) { return {}; } TokenType beginAsynchronous(ArgumentType) { return {}; }
void tickAsynchronous(Token<false>, ArgumentType) {} void tickAsynchronous(ArgumentType) {}
void endAsynchronous(Token<false>, ArgumentType) {}
static constexpr bool isActive() { return false; } static constexpr bool isActive() { return false; }
}; };
@@ -323,6 +389,9 @@ public:
using IsActive = std::true_type; using IsActive = std::true_type;
using ArgumentType = typename TraceEvent::ArgumentType; using ArgumentType = typename TraceEvent::ArgumentType;
using StringType = typename TraceEvent::StringType; using StringType = typename TraceEvent::StringType;
using TokenType = Token<Category, true>;
friend TokenType;
template<typename EventQueue> template<typename EventQueue>
Category(ArgumentType name, EventQueue &queue) Category(ArgumentType name, EventQueue &queue)
@@ -334,43 +403,13 @@ public:
idCounter = globalIdCounter += 1ULL << 32; idCounter = globalIdCounter += 1ULL << 32;
} }
Token<true> beginAsynchronous(ArgumentType traceName) TokenType beginAsynchronous(ArgumentType traceName)
{ {
auto id = ++idCounter; std::size_t id = ++idCounter;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'b';
traceEvent.id = id;
return id; beginAsynchronous(id, traceName);
}
void tickAsynchronous(Token<true> token, ArgumentType traceName) return {traceName, id, *this};
{
if (!token)
return;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'n';
traceEvent.id = *token;
}
void endAsynchronous(Token<true> token, ArgumentType traceName)
{
if (!token)
return;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'e';
traceEvent.id = *token;
} }
EnabledEventQueue<TraceEvent> &eventQueue() const { return m_eventQueue; } EnabledEventQueue<TraceEvent> &eventQueue() const { return m_eventQueue; }
@@ -379,6 +418,39 @@ public:
static constexpr bool isActive() { return true; } static constexpr bool isActive() { return true; }
private:
void beginAsynchronous(std::size_t id, StringType traceName)
{
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.type = 'b';
traceEvent.id = id;
traceEvent.time = Clock::now();
}
void tickAsynchronous(std::size_t id, StringType traceName)
{
auto time = Clock::now();
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = time;
traceEvent.type = 'n';
traceEvent.id = id;
}
void endAsynchronous(std::size_t id, StringType traceName)
{
auto time = Clock::now();
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = time;
traceEvent.type = 'e';
traceEvent.id = id;
}
private: private:
StringType m_name; StringType m_name;
EnabledEventQueue<TraceEvent> &m_eventQueue; EnabledEventQueue<TraceEvent> &m_eventQueue;

92
src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
View File

@@ -15,8 +15,9 @@ namespace QmlDesigner {
using namespace NanotraceHR::Literals; using namespace NanotraceHR::Literals;
namespace ImageCache {
namespace { namespace {
using TraceFile = NanotraceHR::TraceFile<imageCacheTracingIsEnabled()>; using TraceFile = NanotraceHR::TraceFile<ImageCache::tracingIsEnabled()>;
TraceFile traceFile{"qml_designer.json"}; TraceFile traceFile{"qml_designer.json"};
@@ -24,14 +25,14 @@ thread_local auto eventQueueData = NanotraceHR::makeEventQueueData<NanotraceHR::
traceFile); traceFile);
thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue(); thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue();
thread_local NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> category{"image cache"_t, thread_local Category category_{"image cache"_t, eventQueue};
eventQueue};
} // namespace } // namespace
NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory() Category &category()
{ {
return category; return category_;
} }
} // namespace ImageCache
AsynchronousImageCache::AsynchronousImageCache(ImageCacheStorageInterface &storage, AsynchronousImageCache::AsynchronousImageCache(ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator, ImageCacheGeneratorInterface &generator,
@@ -52,7 +53,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
ImageCache::CaptureImageCallback captureCallback, ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback, ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData, ImageCache::AuxiliaryData auxiliaryData,
ImageCacheTraceToken traceToken, ImageCache::TraceToken traceToken,
ImageCacheStorageInterface &storage, ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator, ImageCacheGeneratorInterface &generator,
TimeStampProviderInterface &timeStampProvider) TimeStampProviderInterface &timeStampProvider)
@@ -62,11 +63,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
const auto timeStamp = timeStampProvider.timeStamp(name); const auto timeStamp = timeStampProvider.timeStamp(name);
auto requestImageFromStorage = [&](RequestType requestType) { auto requestImageFromStorage = [&](RequestType requestType) {
imageCacheCategory().tickAsynchronous(traceToken, "start fetching image from storage"_t); auto storageTraceToken = traceToken.begin("fetching image from storage"_t);
QScopeGuard finally{[=] {
imageCacheCategory().tickAsynchronous(traceToken, "end fetching image from storage"_t);
}};
switch (requestType) { switch (requestType) {
case RequestType::Image: case RequestType::Image:
return storage.fetchImage(id, timeStamp); return storage.fetchImage(id, timeStamp);
@@ -80,22 +77,24 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
return storage.fetchImage(id, timeStamp); return storage.fetchImage(id, timeStamp);
}; };
const auto entry = requestImageFromStorage(requestType); const auto entry = requestImageFromStorage(requestType);
if (entry) { if (entry) {
if (entry->isNull()) { if (entry->isNull()) {
traceToken.tick("there was an null image in storage"_t);
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed);
imageCacheCategory().endAsynchronous(traceToken,
"abort image request because entry in database is null"_t);
} else { } else {
captureCallback(*entry); captureCallback(*entry);
imageCacheCategory().endAsynchronous(traceToken, "image request delivered from storage"_t);
} }
traceToken.end();
} else { } else {
auto callback = auto imageGeneratedCallback =
[captureCallback = std::move(captureCallback), [captureCallback = std::move(captureCallback),
requestType, requestType](const QImage &image,
traceToken](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) { const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken traceToken) {
auto selectImage = [](RequestType requestType, auto selectImage = [](RequestType requestType,
const QImage &image, const QImage &image,
const QImage &midSizeImage, const QImage &midSizeImage,
@@ -113,19 +112,27 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
return image; return image;
}; };
traceToken.end();
captureCallback(selectImage(requestType, image, midSizeImage, smallImage)); captureCallback(selectImage(requestType, image, midSizeImage, smallImage));
imageCacheCategory().endAsynchronous(traceToken,
"image request delivered from generation"_t);
}; };
imageCacheCategory().tickAsynchronous(traceToken, "request image generation"_t); auto imageGenerationAbortedCallback =
[abortCallback = std::move(abortCallback)](ImageCache::AbortReason reason,
ImageCache::TraceToken traceToken) {
traceToken.tick("image could not be created"_t);
traceToken.end();
abortCallback(reason);
};
traceToken.tick("call the generator"_t);
generator.generateImage(name, generator.generateImage(name,
extraId, extraId,
timeStamp, timeStamp,
std::move(callback), std::move(imageGeneratedCallback),
std::move(abortCallback), std::move(imageGenerationAbortedCallback),
std::move(auxiliaryData)); std::move(auxiliaryData),
std::move(traceToken));
} }
} }
@@ -135,7 +142,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData) ImageCache::AuxiliaryData auxiliaryData)
{ {
auto traceToken = imageCacheCategory().beginAsynchronous( auto traceToken = ImageCache::category().beginAsynchronous(
"request image in asynchornous image cache"_t); "request image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name), m_taskQueue.addTask(std::move(name),
std::move(extraId), std::move(extraId),
@@ -143,7 +150,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
std::move(abortCallback), std::move(abortCallback),
std::move(auxiliaryData), std::move(auxiliaryData),
RequestType::Image, RequestType::Image,
traceToken); std ::move(traceToken));
} }
void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name, void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
@@ -152,7 +159,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData) ImageCache::AuxiliaryData auxiliaryData)
{ {
auto traceToken = imageCacheCategory().beginAsynchronous( auto traceToken = ImageCache::category().beginAsynchronous(
"request mid size image in asynchornous image cache"_t); "request mid size image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name), m_taskQueue.addTask(std::move(name),
std::move(extraId), std::move(extraId),
@@ -160,7 +167,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
std::move(abortCallback), std::move(abortCallback),
std::move(auxiliaryData), std::move(auxiliaryData),
RequestType::MidSizeImage, RequestType::MidSizeImage,
traceToken); std ::move(traceToken));
} }
void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name, void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
@@ -169,7 +176,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData) ImageCache::AuxiliaryData auxiliaryData)
{ {
auto traceToken = imageCacheCategory().beginAsynchronous( auto traceToken = ImageCache::category().beginAsynchronous(
"request small size image in asynchornous image cache"_t); "request small size image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name), m_taskQueue.addTask(std::move(name),
std::move(extraId), std::move(extraId),
@@ -177,7 +184,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
std::move(abortCallback), std::move(abortCallback),
std::move(auxiliaryData), std::move(auxiliaryData),
RequestType::SmallImage, RequestType::SmallImage,
traceToken); std ::move(traceToken));
} }
void AsynchronousImageCache::clean() void AsynchronousImageCache::clean()
@@ -186,4 +193,31 @@ void AsynchronousImageCache::clean()
m_taskQueue.clean(); m_taskQueue.clean();
} }
void AsynchronousImageCache::Dispatch::operator()(Entry &entry)
{
using namespace NanotraceHR::Literals;
request(entry.name,
entry.extraId,
entry.requestType,
std::move(entry.captureCallback),
std::move(entry.abortCallback),
std::move(entry.auxiliaryData),
std::move(entry.traceToken),
storage,
generator,
timeStampProvider);
}
void AsynchronousImageCache::Clean::operator()(Entry &entry)
{
using namespace NanotraceHR::Literals;
entry.traceToken.tick("cleaning up in the cache"_t);
entry.abortCallback(ImageCache::AbortReason::Abort);
entry.traceToken.end();
}
} // namespace QmlDesigner } // namespace QmlDesigner

7
src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
View File

@@ -46,7 +46,10 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
if (currentModifiedTime < (storageModifiedTime + pause)) if (currentModifiedTime < (storageModifiedTime + pause))
return; return;
auto capture = [&](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) { auto capture = [&](const QImage &image,
const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken) {
storage.storeImage(id, currentModifiedTime, image, midSizeImage, smallImage); storage.storeImage(id, currentModifiedTime, image, midSizeImage, smallImage);
}; };
@@ -54,7 +57,7 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
extraId, extraId,
std::move(auxiliaryData), std::move(auxiliaryData),
std::move(capture), std::move(capture),
ImageCache::AbortCallback{}); ImageCache::InternalAbortCallback{});
} }
void AsynchronousImageFactory::clean() void AsynchronousImageFactory::clean()

34
src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
View File

@@ -73,8 +73,12 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{ {
using namespace NanotraceHR::Literals;
auto collectorTraceToken = traceToken.begin("generate image in standard collector"_t);
RewriterView rewriterView{m_externalDependencies, RewriterView::Amend}; RewriterView rewriterView{m_externalDependencies, RewriterView::Amend};
NodeInstanceView nodeInstanceView{m_connectionManager, m_externalDependencies}; NodeInstanceView nodeInstanceView{m_connectionManager, m_externalDependencies};
nodeInstanceView.setCaptureImageMinimumAndMaximumSize(captureImageMinimumSize, nodeInstanceView.setCaptureImageMinimumAndMaximumSize(captureImageMinimumSize,
@@ -101,7 +105,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
if (!rewriterView.errors().isEmpty() || (!rewriterView.rootModelNode().metaInfo().isGraphicalItem() if (!rewriterView.errors().isEmpty() || (!rewriterView.rootModelNode().metaInfo().isGraphicalItem()
&& !is3DRoot)) { && !is3DRoot)) {
if (abortCallback) if (abortCallback)
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
return; return;
} }
@@ -117,21 +121,17 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
if (stateNode.isValid()) if (stateNode.isValid())
rewriterView.setCurrentStateNode(stateNode); rewriterView.setCurrentStateNode(stateNode);
auto callback = [=, captureCallback = std::move(captureCallback)](const QImage &image) { QImage captureImage;
if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
|| !image.isNull()) { auto callback = [&](const QImage &image) { captureImage = image; };
QImage midSizeImage = scaleImage(image, QSize{300, 300});
QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
captureCallback(image, midSizeImage, smallImage);
}
};
if (!m_target) if (!m_target)
return; return;
nodeInstanceView.setTarget(m_target.data()); nodeInstanceView.setTarget(m_target.data());
m_connectionManager.setCallback(std::move(callback)); m_connectionManager.setCallback(std::move(callback));
nodeInstanceView.setCrashCallback([=] { abortCallback(ImageCache::AbortReason::Failed); }); bool isCrashed = false;
nodeInstanceView.setCrashCallback([&] { isCrashed = true; });
model->setNodeInstanceView(&nodeInstanceView); model->setNodeInstanceView(&nodeInstanceView);
bool capturedDataArrived = m_connectionManager.waitForCapturedData(); bool capturedDataArrived = m_connectionManager.waitForCapturedData();
@@ -142,8 +142,18 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
model->setNodeInstanceView({}); model->setNodeInstanceView({});
model->setRewriterView({}); model->setRewriterView({});
if (isCrashed)
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
if (!capturedDataArrived && abortCallback) if (!capturedDataArrived && abortCallback)
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
|| !captureImage.isNull()) {
QImage midSizeImage = scaleImage(captureImage, QSize{300, 300});
QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
captureCallback(captureImage, midSizeImage, smallImage, std::move(traceToken));
}
} }
ImageCacheCollectorInterface::ImageTuple ImageCacheCollector::createImage( ImageCacheCollectorInterface::ImageTuple ImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
View File

@@ -41,7 +41,8 @@ public:
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) override; AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override;
ImageTuple createImage(Utils::SmallStringView filePath, ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state, Utils::SmallStringView state,

5
src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h
View File

@@ -15,14 +15,15 @@ class ImageCacheCollectorInterface
{ {
public: public:
using CaptureCallback = ImageCache::CaptureImageWithScaledImagesCallback; using CaptureCallback = ImageCache::CaptureImageWithScaledImagesCallback;
using AbortCallback = ImageCache::AbortCallback; using AbortCallback = ImageCache::InternalAbortCallback;
using ImageTuple = std::tuple<QImage, QImage, QImage>; using ImageTuple = std::tuple<QImage, QImage, QImage>;
virtual void start(Utils::SmallStringView filePath, virtual void start(Utils::SmallStringView filePath,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {})
= 0; = 0;
virtual ImageTuple createImage(Utils::SmallStringView filePath, virtual ImageTuple createImage(Utils::SmallStringView filePath,

17
src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h
View File

@@ -12,13 +12,15 @@ class ImageCacheDispatchCollector final : public ImageCacheCollectorInterface
{ {
public: public:
ImageCacheDispatchCollector(CollectorEntries collectors) ImageCacheDispatchCollector(CollectorEntries collectors)
: m_collectors{std::move(collectors)} {}; : m_collectors{std::move(collectors)}
{}
void start(Utils::SmallStringView filePath, void start(Utils::SmallStringView filePath,
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) override AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override
{ {
std::apply( std::apply(
[&](const auto &...collectors) { [&](const auto &...collectors) {
@@ -27,6 +29,7 @@ public:
auxiliaryData, auxiliaryData,
std::move(captureCallback), std::move(captureCallback),
std::move(abortCallback), std::move(abortCallback),
std::move(traceToken),
collectors...); collectors...);
}, },
m_collectors); m_collectors);
@@ -61,6 +64,7 @@ private:
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback, AbortCallback abortCallback,
ImageCache::TraceToken traceToken,
const Collector &collector, const Collector &collector,
const Collectors &...collectors) const Collectors &...collectors)
{ {
@@ -69,13 +73,15 @@ private:
state, state,
auxiliaryData, auxiliaryData,
std::move(captureCallback), std::move(captureCallback),
std::move(abortCallback)); std::move(abortCallback),
std::move(traceToken));
} else { } else {
dispatchStart(filePath, dispatchStart(filePath,
state, state,
auxiliaryData, auxiliaryData,
std::move(captureCallback), std::move(captureCallback),
std::move(abortCallback), std::move(abortCallback),
std::move(traceToken),
collectors...); collectors...);
} }
} }
@@ -84,10 +90,11 @@ private:
Utils::SmallStringView, Utils::SmallStringView,
const ImageCache::AuxiliaryData &, const ImageCache::AuxiliaryData &,
CaptureCallback, CaptureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{ {
qWarning() << "ImageCacheDispatchCollector: cannot handle file type."; qWarning() << "ImageCacheDispatchCollector: cannot handle file type.";
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
} }
template<typename Collector, typename... Collectors> template<typename Collector, typename... Collectors>

7
src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
View File

@@ -94,7 +94,8 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
Utils::SmallStringView, Utils::SmallStringView,
const ImageCache::AuxiliaryData &auxiliaryDataValue, const ImageCache::AuxiliaryData &auxiliaryDataValue,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{ {
QFont font; QFont font;
if (resolveFont(QString(name), font) >= 0) { if (resolveFont(QString(name), font) >= 0) {
@@ -107,12 +108,12 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
QImage image = createFontImage(text, textColor, font, size); QImage image = createFontImage(text, textColor, font, size);
if (!image.isNull()) { if (!image.isNull()) {
captureCallback(std::move(image), {}, {}); captureCallback(std::move(image), {}, {}, std::move(traceToken));
return; return;
} }
} }
} }
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
} }
ImageCacheCollectorInterface::ImageTuple ImageCacheFontCollector::createImage( ImageCacheCollectorInterface::ImageTuple ImageCacheFontCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h
View File

@@ -18,7 +18,8 @@ public:
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) override; AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override;
ImageTuple createImage(Utils::SmallStringView filePath, ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,

59
src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp
View File

@@ -42,8 +42,9 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp, Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback, ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback, ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData) ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken traceToken)
{ {
{ {
std::lock_guard lock{m_mutex}; std::lock_guard lock{m_mutex};
@@ -64,7 +65,8 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
std::move(auxiliaryData), std::move(auxiliaryData),
timeStamp, timeStamp,
std::move(captureCallback), std::move(captureCallback),
std::move(abortCallback)); std::move(abortCallback),
std::move(traceToken));
} }
} }
@@ -89,9 +91,14 @@ void callCallbacks(const Callbacks &callbacks, Argument &&...arguments)
void ImageCacheGenerator::clean() void ImageCacheGenerator::clean()
{ {
using namespace NanotraceHR::Literals;
std::lock_guard lock{m_mutex}; std::lock_guard lock{m_mutex};
for (Task &task : m_tasks) for (Task &task : m_tasks) {
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort); task.traceToken.tick("cleaning up in the generator"_t);
task.traceToken.end();
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort, std::move(task.traceToken));
}
m_tasks.clear(); m_tasks.clear();
} }
@@ -124,27 +131,43 @@ void ImageCacheGenerator::startGeneration()
task.filePath, task.filePath,
task.extraId, task.extraId,
std::move(task.auxiliaryData), std::move(task.auxiliaryData),
[this, task](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) { [this,
abortCallbacks = task.abortCallbacks,
captureCallbacks = std::move(task.captureCallbacks),
filePath = task.filePath,
extraId = task.extraId,
timeStamp = task.timeStamp](const QImage &image,
const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken traceToken) {
if (image.isNull() && midSizeImage.isNull() && smallImage.isNull()) if (image.isNull() && midSizeImage.isNull() && smallImage.isNull())
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Failed); callCallbacks(abortCallbacks,
ImageCache::AbortReason::Failed,
std::move(traceToken));
else else
callCallbacks(task.captureCallbacks, image, midSizeImage, smallImage); callCallbacks(captureCallbacks,
image,
midSizeImage,
smallImage,
std::move(traceToken));
m_storage.storeImage(createId(task.filePath, task.extraId), m_storage.storeImage(createId(filePath, extraId),
task.timeStamp, timeStamp,
image, image,
midSizeImage, midSizeImage,
smallImage); smallImage);
}, },
[this, task](ImageCache::AbortReason abortReason) { [this,
callCallbacks(task.abortCallbacks, abortReason); abortCallbacks = task.abortCallbacks,
filePath = task.filePath,
extraId = task.extraId,
timeStamp = task.timeStamp](ImageCache::AbortReason abortReason,
ImageCache::TraceToken traceToken) {
callCallbacks(abortCallbacks, abortReason, std::move(traceToken));
if (abortReason != ImageCache::AbortReason::Abort) if (abortReason != ImageCache::AbortReason::Abort)
m_storage.storeImage(createId(task.filePath, task.extraId), m_storage.storeImage(createId(filePath, extraId), timeStamp, {}, {}, {});
task.timeStamp, },
{}, std::move(task.traceToken));
{},
{});
});
std::lock_guard lock{m_mutex}; std::lock_guard lock{m_mutex};
if (m_tasks.empty()) if (m_tasks.empty())

14
src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h
View File

@@ -34,8 +34,9 @@ public:
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp, Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback, ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback, ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData) override; ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken traceToken = {}) override;
void clean() override; void clean() override;
void waitForFinished() override; void waitForFinished() override;
@@ -44,26 +45,30 @@ private:
struct Task struct Task
{ {
Task() = default; Task() = default;
Task(Utils::SmallStringView filePath, Task(Utils::SmallStringView filePath,
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
ImageCache::AuxiliaryData &&auxiliaryData, ImageCache::AuxiliaryData &&auxiliaryData,
Sqlite::TimeStamp timeStamp, Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback, ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback) ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::TraceToken traceToken)
: filePath(filePath) : filePath(filePath)
, extraId(std::move(extraId)) , extraId(std::move(extraId))
, auxiliaryData(std::move(auxiliaryData)) , auxiliaryData(std::move(auxiliaryData))
, captureCallbacks({std::move(captureCallback)}) , captureCallbacks({std::move(captureCallback)})
, abortCallbacks({std::move(abortCallback)}) , abortCallbacks({std::move(abortCallback)})
, timeStamp(timeStamp) , timeStamp(timeStamp)
, traceToken{std::move(traceToken)}
{} {}
Utils::PathString filePath; Utils::PathString filePath;
Utils::SmallString extraId; Utils::SmallString extraId;
ImageCache::AuxiliaryData auxiliaryData; ImageCache::AuxiliaryData auxiliaryData;
std::vector<ImageCache::CaptureImageWithScaledImagesCallback> captureCallbacks; std::vector<ImageCache::CaptureImageWithScaledImagesCallback> captureCallbacks;
std::vector<ImageCache::AbortCallback> abortCallbacks; std::vector<ImageCache::InternalAbortCallback> abortCallbacks;
Sqlite::TimeStamp timeStamp; Sqlite::TimeStamp timeStamp;
ImageCache::TraceToken traceToken;
}; };
void startGeneration(); void startGeneration();
@@ -71,7 +76,6 @@ private:
[[nodiscard]] std::tuple<std::unique_lock<std::mutex>, bool> waitForEntries(); [[nodiscard]] std::tuple<std::unique_lock<std::mutex>, bool> waitForEntries();
void stopThread(); void stopThread();
private:
private: private:
std::unique_ptr<QThread> m_backgroundThread; std::unique_ptr<QThread> m_backgroundThread;
mutable std::mutex m_mutex; mutable std::mutex m_mutex;

5
src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h
View File

@@ -18,8 +18,9 @@ public:
Utils::SmallStringView extraId, Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp, Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback, ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback, ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData) ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken = {})
= 0; = 0;
virtual void clean() = 0; virtual void clean() = 0;

6
src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp
View File

@@ -30,7 +30,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{ {
QTemporaryFile file(QDir::tempPath() + "/mesh-XXXXXX.qml"); QTemporaryFile file(QDir::tempPath() + "/mesh-XXXXXX.qml");
if (file.open()) { if (file.open()) {
@@ -63,7 +64,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
Utils::PathString path{file.fileName()}; Utils::PathString path{file.fileName()};
m_imageCacheCollector.start(path, state, auxiliaryData, captureCallback, abortCallback); m_imageCacheCollector
.start(path, state, auxiliaryData, captureCallback, abortCallback, std::move(traceToken));
} }
ImageCacheCollectorInterface::ImageTuple MeshImageCacheCollector::createImage( ImageCacheCollectorInterface::ImageTuple MeshImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h
View File

@@ -29,7 +29,8 @@ public:
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) override; AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {}) override;
ImageTuple createImage(Utils::SmallStringView filePath, ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state, Utils::SmallStringView state,

2
src/plugins/qmldesigner/designercore/imagecache/taskqueue.h
View File

@@ -83,7 +83,7 @@ private:
Task task = std::move(m_tasks.front()); Task task = std::move(m_tasks.front());
m_tasks.pop_front(); m_tasks.pop_front();
return {task}; return {std::move(task)};
} }
void ensureThreadIsRunning() void ensureThreadIsRunning()

7
src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp
View File

@@ -17,7 +17,8 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView, Utils::SmallStringView,
const ImageCache::AuxiliaryData &, const ImageCache::AuxiliaryData &,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{ {
Asset asset {QString(name)}; Asset asset {QString(name)};
QImage image; QImage image;
@@ -31,11 +32,11 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
} }
if (image.isNull()) if (image.isNull())
abortCallback(ImageCache::AbortReason::Failed); abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
else else
image = image.scaled(QSize{300, 300}, Qt::KeepAspectRatio); image = image.scaled(QSize{300, 300}, Qt::KeepAspectRatio);
captureCallback({}, image, {}); captureCallback({}, image, {}, std::move(traceToken));
} }
ImageCacheCollectorInterface::ImageTuple TextureImageCacheCollector::createImage( ImageCacheCollectorInterface::ImageTuple TextureImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h
View File

@@ -17,7 +17,8 @@ public:
Utils::SmallStringView state, Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData, const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback, CaptureCallback captureCallback,
AbortCallback abortCallback) override; AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {}) override;
ImageTuple createImage(Utils::SmallStringView filePath, ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state, Utils::SmallStringView state,

46
src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
View File

@@ -3,10 +3,11 @@
#pragma once #pragma once
#include <qmldesignercorelib_exports.h>
#include "asynchronousimagecacheinterface.h" #include "asynchronousimagecacheinterface.h"
#include <imagecache/taskqueue.h> #include <imagecache/taskqueue.h>
#include <nanotrace/nanotracehr.h>
#include <condition_variable> #include <condition_variable>
#include <deque> #include <deque>
@@ -22,19 +23,6 @@ class ImageCacheStorageInterface;
class ImageCacheGeneratorInterface; class ImageCacheGeneratorInterface;
class ImageCacheCollectorInterface; class ImageCacheCollectorInterface;
constexpr bool imageCacheTracingIsEnabled()
{
#ifdef ENABLE_IMAGE_CACHE_TRACING
return NanotraceHR::isTracerActive();
#else
return false;
#endif
}
using ImageCacheTraceToken = NanotraceHR::Token<imageCacheTracingIsEnabled()>;
NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory();
class AsynchronousImageCache final : public AsynchronousImageCacheInterface class AsynchronousImageCache final : public AsynchronousImageCacheInterface
{ {
public: public:
@@ -74,14 +62,14 @@ private:
ImageCache::AbortCallback &&abortCallback, ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData, ImageCache::AuxiliaryData &&auxiliaryData,
RequestType requestType, RequestType requestType,
ImageCacheTraceToken traceToken) ImageCache::TraceToken traceToken)
: name{std::move(name)} : name{std::move(name)}
, extraId{std::move(extraId)} , extraId{std::move(extraId)}
, captureCallback{std::move(captureCallback)} , captureCallback{std::move(captureCallback)}
, abortCallback{std::move(abortCallback)} , abortCallback{std::move(abortCallback)}
, auxiliaryData{std::move(auxiliaryData)} , auxiliaryData{std::move(auxiliaryData)}
, requestType{requestType} , requestType{requestType}
, traceToken{traceToken} , traceToken{std::move(traceToken)}
{} {}
Utils::PathString name; Utils::PathString name;
@@ -90,7 +78,7 @@ private:
ImageCache::AbortCallback abortCallback; ImageCache::AbortCallback abortCallback;
ImageCache::AuxiliaryData auxiliaryData; ImageCache::AuxiliaryData auxiliaryData;
RequestType requestType = RequestType::Image; RequestType requestType = RequestType::Image;
ImageCacheTraceToken traceToken; ImageCache::TraceToken traceToken;
}; };
static void request(Utils::SmallStringView name, static void request(Utils::SmallStringView name,
@@ -99,26 +87,14 @@ private:
ImageCache::CaptureImageCallback captureCallback, ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback, ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData, ImageCache::AuxiliaryData auxiliaryData,
ImageCacheTraceToken traceToken, ImageCache::TraceToken traceToken,
ImageCacheStorageInterface &storage, ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator, ImageCacheGeneratorInterface &generator,
TimeStampProviderInterface &timeStampProvider); TimeStampProviderInterface &timeStampProvider);
struct Dispatch struct Dispatch
{ {
void operator()(Entry &entry) QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
{
request(entry.name,
entry.extraId,
entry.requestType,
std::move(entry.captureCallback),
std::move(entry.abortCallback),
std::move(entry.auxiliaryData),
entry.traceToken,
storage,
generator,
timeStampProvider);
}
ImageCacheStorageInterface &storage; ImageCacheStorageInterface &storage;
ImageCacheGeneratorInterface &generator; ImageCacheGeneratorInterface &generator;
@@ -127,13 +103,7 @@ private:
struct Clean struct Clean
{ {
void operator()(Entry &entry) QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
{
using namespace NanotraceHR::Literals;
entry.abortCallback(ImageCache::AbortReason::Abort);
imageCacheCategory().endAsynchronous(entry.traceToken, "aborted for cleanup"_t);
}
}; };
private: private:

20
src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
View File

@@ -3,6 +3,7 @@
#pragma once #pragma once
#include <nanotrace/nanotracehr.h>
#include <utils/span.h> #include <utils/span.h>
#include <QImage> #include <QImage>
@@ -16,6 +17,19 @@ namespace QmlDesigner {
namespace ImageCache { namespace ImageCache {
constexpr bool tracingIsEnabled()
{
#ifdef ENABLE_IMAGE_CACHE_TRACING
return NanotraceHR::isTracerActive();
#else
return false;
#endif
}
using Category = NanotraceHR::StringViewCategory<tracingIsEnabled()>;
using TraceToken = Category::TokenType;
Category &category();
class FontCollectorSizeAuxiliaryData class FontCollectorSizeAuxiliaryData
{ {
public: public:
@@ -46,9 +60,11 @@ using AuxiliaryData = std::variant<std::monostate,
enum class AbortReason : char { Abort, Failed, NoEntry }; enum class AbortReason : char { Abort, Failed, NoEntry };
using CaptureImageCallback = std::function<void(const QImage &)>; using CaptureImageCallback = std::function<void(const QImage &)>;
using CaptureImageWithScaledImagesCallback = std::function< using CaptureImageWithScaledImagesCallback = std::function<void(
void(const QImage &image, const QImage &midSizeImage, const QImage &smallImage)>; const QImage &image, const QImage &midSizeImage, const QImage &smallImage, ImageCache::TraceToken)>;
using AbortCallback = std::function<void(ImageCache::AbortReason)>; using AbortCallback = std::function<void(ImageCache::AbortReason)>;
using InternalAbortCallback = std::function<void(ImageCache::AbortReason, ImageCache::TraceToken)>;
} // namespace ImageCache } // namespace ImageCache
} // namespace QmlDesigner } // namespace QmlDesigner

3
tests/unit/tests/mocks/imagecachecollectormock.h
View File

@@ -16,7 +16,8 @@ public:
Utils::SmallStringView state, Utils::SmallStringView state,
const QmlDesigner::ImageCache::AuxiliaryData &auxiliaryData, const QmlDesigner::ImageCache::AuxiliaryData &auxiliaryData,
ImageCacheCollectorInterface::CaptureCallback captureCallback, ImageCacheCollectorInterface::CaptureCallback captureCallback,
ImageCacheCollectorInterface::AbortCallback abortCallback), ImageCacheCollectorInterface::AbortCallback abortCallback,
QmlDesigner::ImageCache::TraceToken),
(override)); (override));
MOCK_METHOD(ImageTuple, MOCK_METHOD(ImageTuple,

5
tests/unit/tests/mocks/mockimagecachegenerator.h
View File

@@ -16,8 +16,9 @@ public:
Utils::SmallStringView state, Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp, Sqlite::TimeStamp timeStamp,
QmlDesigner::ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback, QmlDesigner::ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
QmlDesigner::ImageCache::AbortCallback &&abortCallback, QmlDesigner::ImageCache::InternalAbortCallback &&abortCallback,
QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData), QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData,
QmlDesigner::ImageCache::TraceToken),
(override)); (override));
MOCK_METHOD(void, clean, (), (override)); MOCK_METHOD(void, clean, (), (override));
MOCK_METHOD(void, waitForFinished, (), (override)); MOCK_METHOD(void, waitForFinished, (), (override));

90
tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
View File

@@ -93,8 +93,8 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
.WillByDefault(Return(Sqlite::TimeStamp{123})); .WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _)) generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml", cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -104,9 +104,9 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_from_generator) TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) { .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify(); notification.notify();
}); });
@@ -120,9 +120,9 @@ TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_f
TEST_F(AsynchronousImageCache, request_image_calls_abort_callback_from_generator) TEST_F(AsynchronousImageCache, request_image_calls_abort_callback_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) { .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify(); notification.notify();
}); });
@@ -200,8 +200,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
.WillByDefault(Return(Sqlite::TimeStamp{123})); .WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _)) generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml", cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -211,9 +211,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_with_image_from_generator) TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_with_image_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) { .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify(); notification.notify();
}); });
@@ -227,9 +227,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_wit
TEST_F(AsynchronousImageCache, request_mid_size_image_calls_abort_callback_from_generator) TEST_F(AsynchronousImageCache, request_mid_size_image_calls_abort_callback_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) { .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify(); notification.notify();
}); });
@@ -306,8 +306,8 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
.WillByDefault(Return(Sqlite::TimeStamp{123})); .WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _)) generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml", cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -317,9 +317,9 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_image_from_generator) TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_image_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) { .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify(); notification.notify();
}); });
@@ -333,9 +333,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_i
TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_generator) TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_generator)
{ {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) { .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify(); notification.notify();
}); });
@@ -349,9 +349,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_gen
TEST_F(AsynchronousImageCache, clean_removes_entries) TEST_F(AsynchronousImageCache, clean_removes_entries)
{ {
EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _)) EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto) { .WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}); captureCallback(QImage{}, QImage{}, QImage{}, {});
waitInThread.wait(); waitInThread.wait();
}); });
cache.requestSmallImage("/path/to/Component1.qml", cache.requestSmallImage("/path/to/Component1.qml",
@@ -369,8 +369,8 @@ TEST_F(AsynchronousImageCache, clean_removes_entries)
TEST_F(AsynchronousImageCache, clean_calls_abort) TEST_F(AsynchronousImageCache, clean_calls_abort)
{ {
ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _)) ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto &&, auto) { waitInThread.wait(); }); .WillByDefault([&](auto, auto, auto, auto, auto &&, auto, auto) { waitInThread.wait(); });
cache.requestSmallImage("/path/to/Component1.qml", cache.requestSmallImage("/path/to/Component1.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction()); mockAbortCallback.AsStdFunction());
@@ -399,8 +399,9 @@ TEST_F(AsynchronousImageCache, after_clean_new_jobs_works)
{ {
cache.clean(); cache.clean();
EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _)) EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto &&, auto) { notification.notify(); }); .WillRepeatedly(
[&](auto, auto, auto, auto &&, auto &&, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml", cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -460,8 +461,8 @@ TEST_F(AsynchronousImageCache, request_image_with_extra_id_request_image_from_ge
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage( generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _)) Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml", cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -477,8 +478,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_extra_id_request_imag
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage( generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _)) Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml", cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -494,8 +495,8 @@ TEST_F(AsynchronousImageCache, request_small_image_with_extra_id_request_image_f
EXPECT_CALL(mockGenerator, EXPECT_CALL(mockGenerator,
generateImage( generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _)) Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml", cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -521,8 +522,9 @@ TEST_F(AsynchronousImageCache, request_image_with_auxiliary_data_request_image_f
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes, AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color")))))) Eq(u"color")))),
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml", cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -549,8 +551,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_auxiliary_data_reques
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes, AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color")))))) Eq(u"color")))),
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml", cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),
@@ -577,8 +580,9 @@ TEST_F(AsynchronousImageCache, request_small_image_with_auxiliary_data_request_i
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes, AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color")))))) Eq(u"color")))),
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); }); _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml", cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(), mockCaptureCallback.AsStdFunction(),

27
tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
View File

@@ -43,8 +43,9 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector)
IsEmpty(), IsEmpty(),
VariantWith<std::monostate>(std::monostate{}), VariantWith<std::monostate>(std::monostate{}),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml"); factory.generate("/path/to/Component.qml");
notification.wait(); notification.wait();
@@ -57,8 +58,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_extra_id_request_image_from_
Eq("foo"), Eq("foo"),
VariantWith<std::monostate>(std::monostate{}), VariantWith<std::monostate>(std::monostate{}),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml", "foo"); factory.generate("/path/to/Component.qml", "foo");
notification.wait(); notification.wait();
@@ -77,8 +79,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_auxiliary_data_request_image
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")), Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")),
Field(&FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))), Field(&FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml", factory.generate("/path/to/Component.qml",
"foo", "foo",
@@ -99,7 +102,7 @@ TEST_F(AsynchronousImageFactory, dont_request_image_request_image_from_collector
ON_CALL(timeStampProviderMock, timeStamp(Eq("/path/to/Component.qml"))) ON_CALL(timeStampProviderMock, timeStamp(Eq("/path/to/Component.qml")))
.WillByDefault(Return(Sqlite::TimeStamp{1})); .WillByDefault(Return(Sqlite::TimeStamp{1}));
EXPECT_CALL(collectorMock, start(_, _, _, _, _)).Times(0); EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).Times(0);
factory.generate("/path/to/Component.qml"); factory.generate("/path/to/Component.qml");
notification.wait(); notification.wait();
@@ -113,7 +116,7 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
.WillByDefault(Return(Sqlite::TimeStamp{125})); .WillByDefault(Return(Sqlite::TimeStamp{125}));
ON_CALL(timeStampProviderMock, pause()).WillByDefault(Return(Sqlite::TimeStamp{1})); ON_CALL(timeStampProviderMock, pause()).WillByDefault(Return(Sqlite::TimeStamp{1}));
EXPECT_CALL(collectorMock, start(_, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto) { EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto, auto) {
notification.notify(); notification.notify();
}); });
@@ -123,15 +126,15 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
TEST_F(AsynchronousImageFactory, clean_removes_entries) TEST_F(AsynchronousImageFactory, clean_removes_entries)
{ {
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) {
notification.notify(); notification.notify();
waitInThread.wait(); waitInThread.wait();
}); });
factory.generate("/path/to/Component1.qml"); factory.generate("/path/to/Component1.qml");
notification.wait(); notification.wait();
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _)).Times(0); EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _, _)).Times(0);
factory.generate("/path/to/Component3.qml"); factory.generate("/path/to/Component3.qml");
factory.clean(); factory.clean();
@@ -147,8 +150,9 @@ TEST_F(AsynchronousImageFactory, after_clean_new_jobs_works)
IsEmpty(), IsEmpty(),
VariantWith<std::monostate>(std::monostate{}), VariantWith<std::monostate>(std::monostate{}),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml"); factory.generate("/path/to/Component.qml");
notification.wait(); notification.wait();
@@ -166,9 +170,10 @@ TEST_F(AsynchronousImageFactory, capture_image_callback_stores_image)
Eq("id"), Eq("id"),
VariantWith<std::monostate>(std::monostate{}), VariantWith<std::monostate>(std::monostate{}),
_, _,
_,
_)) _))
.WillByDefault([&](auto, auto, auto, auto capture, auto) { .WillByDefault([&](auto, auto, auto, auto capture, auto, auto) {
capture(image1, midSizeImage1, smallImage1); capture(image1, midSizeImage1, smallImage1, {});
}); });
EXPECT_CALL(storageMock, EXPECT_CALL(storageMock,

44
tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
View File

@@ -12,6 +12,7 @@
namespace { namespace {
using QmlDesigner::ImageCache::FontCollectorSizesAuxiliaryData; using QmlDesigner::ImageCache::FontCollectorSizesAuxiliaryData;
using QmlDesigner::ImageCache::TraceToken;
MATCHER_P(IsIcon, icon, std::string(negation ? "isn't " : "is ") + PrintToString(icon)) MATCHER_P(IsIcon, icon, std::string(negation ? "isn't " : "is ") + PrintToString(icon))
{ {
@@ -47,8 +48,8 @@ protected:
protected: protected:
std::vector<QSize> sizes{{20, 11}}; std::vector<QSize> sizes{{20, 11}};
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> captureCallbackMock; NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> captureCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock; NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
NiceMock<ImageCacheCollectorMock> collectorMock1; NiceMock<ImageCacheCollectorMock> collectorMock1;
NiceMock<ImageCacheCollectorMock> collectorMock2; NiceMock<ImageCacheCollectorMock> collectorMock2;
QImage image1{1, 1, QImage::Format_ARGB32}; QImage image1{1, 1, QImage::Format_ARGB32};
@@ -83,8 +84,8 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
}, },
&collectorMock2))}; &collectorMock2))};
EXPECT_CALL(captureCallbackMock, Call(_, _, _)); EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
EXPECT_CALL(abortCallbackMock, Call(_)); EXPECT_CALL(abortCallbackMock, Call(_, _));
EXPECT_CALL(collectorMock2, EXPECT_CALL(collectorMock2,
start(Eq("foo.qml"), start(Eq("foo.qml"),
Eq("state"), Eq("state"),
@@ -93,18 +94,20 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))), Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) { .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
captureCallback({}, {}, {}); captureCallback({}, {}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort); abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
}); });
EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0); EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.qml", collector.start("foo.qml",
"state", "state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"}, FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(), captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction()); abortCallbackMock.AsStdFunction(),
{});
} }
TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start) TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
@@ -119,8 +122,8 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
const QmlDesigner::ImageCache::AuxiliaryData &) { return true; }, const QmlDesigner::ImageCache::AuxiliaryData &) { return true; },
&collectorMock2))}; &collectorMock2))};
EXPECT_CALL(captureCallbackMock, Call(_, _, _)); EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
EXPECT_CALL(abortCallbackMock, Call(_)); EXPECT_CALL(abortCallbackMock, Call(_, _));
EXPECT_CALL(collectorMock1, EXPECT_CALL(collectorMock1,
start(Eq("foo.ui.qml"), start(Eq("foo.ui.qml"),
Eq("state"), Eq("state"),
@@ -129,18 +132,20 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))), Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) { .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
captureCallback({}, {}, {}); captureCallback({}, {}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort); abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
}); });
EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0); EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.ui.qml", collector.start("foo.ui.qml",
"state", "state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"}, FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(), captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction()); abortCallbackMock.AsStdFunction(),
{});
} }
TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file) TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
@@ -155,14 +160,15 @@ TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
const QmlDesigner::ImageCache::AuxiliaryData &) { return false; }, const QmlDesigner::ImageCache::AuxiliaryData &) { return false; },
&collectorMock2))}; &collectorMock2))};
EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0); EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0); EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.mesh", collector.start("foo.mesh",
"state", "state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"}, FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(), captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction()); abortCallbackMock.AsStdFunction(),
{});
} }
TEST_F(ImageCacheDispatchCollector, call_first_collector_create_icon) TEST_F(ImageCacheDispatchCollector, call_first_collector_create_icon)

315
tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
View File

@@ -13,6 +13,8 @@
namespace { namespace {
using QmlDesigner::ImageCache::TraceToken;
class ImageCacheGenerator : public testing::Test class ImageCacheGenerator : public testing::Test
{ {
protected: protected:
@@ -34,8 +36,8 @@ protected:
QImage image1{10, 10, QImage::Format_ARGB32}; QImage image1{10, 10, QImage::Format_ARGB32};
QImage midSizeImage1{5, 5, QImage::Format_ARGB32}; QImage midSizeImage1{5, 5, QImage::Format_ARGB32};
QImage smallImage1{1, 1, QImage::Format_ARGB32}; QImage smallImage1{1, 1, QImage::Format_ARGB32};
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> imageCallbackMock; NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> imageCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock; NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
NiceMock<ImageCacheCollectorMock> collectorMock; NiceMock<ImageCacheCollectorMock> collectorMock;
NiceMock<MockImageCacheStorage> storageMock; NiceMock<MockImageCacheStorage> storageMock;
QmlDesigner::ImageCacheGenerator generator{collectorMock, storageMock}; QmlDesigner::ImageCacheGenerator generator{collectorMock, storageMock};
@@ -43,13 +45,13 @@ protected:
TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback) TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
{ {
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto) { .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
EXPECT_CALL(imageCallbackMock, Call(_, _, _)) EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
.WillRepeatedly( .WillRepeatedly(
[&](const QImage &, const QImage &, const QImage &) { notification.notify(); }); [&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
notification.wait(); notification.wait();
@@ -57,8 +59,8 @@ TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing) TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
{ {
EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _)) EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -67,16 +69,17 @@ TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
TEST_F(ImageCacheGenerator, process_task_after_first_finished) TEST_F(ImageCacheGenerator, process_task_after_first_finished)
{ {
ON_CALL(imageCallbackMock, Call(_, _, _)) ON_CALL(imageCallbackMock, Call(_, _, _, _))
.WillByDefault([&](const QImage &, const QImage &, const QImage &) { notification.notify(); }); .WillByDefault(
[&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) { .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) { .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -86,13 +89,13 @@ TEST_F(ImageCacheGenerator, process_task_after_first_finished)
TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator) TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}, {});
generator.generateImage( generator.generateImage(
"name2", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name2", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
generator.generateImage( generator.generateImage(
@@ -103,9 +106,9 @@ TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
TEST_F(ImageCacheGenerator, store_image) TEST_F(ImageCacheGenerator, store_image)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
EXPECT_CALL(storageMock, EXPECT_CALL(storageMock,
@@ -122,9 +125,9 @@ TEST_F(ImageCacheGenerator, store_image)
TEST_F(ImageCacheGenerator, store_image_with_extra_id) TEST_F(ImageCacheGenerator, store_image_with_extra_id)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
EXPECT_CALL(storageMock, EXPECT_CALL(storageMock,
@@ -141,9 +144,9 @@ TEST_F(ImageCacheGenerator, store_image_with_extra_id)
TEST_F(ImageCacheGenerator, store_null_image) TEST_F(ImageCacheGenerator, store_null_image)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}); captureCallback(QImage{}, QImage{}, QImage{}, {});
}); });
EXPECT_CALL( EXPECT_CALL(
@@ -158,9 +161,9 @@ TEST_F(ImageCacheGenerator, store_null_image)
TEST_F(ImageCacheGenerator, store_null_image_with_extra_id) TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}); captureCallback(QImage{}, QImage{}, QImage{}, {});
}); });
EXPECT_CALL(storageMock, EXPECT_CALL(storageMock,
@@ -182,19 +185,20 @@ TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
TEST_F(ImageCacheGenerator, abort_callback) TEST_F(ImageCacheGenerator, abort_callback)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
}); });
EXPECT_CALL(imageCallbackMock, Call(_, _, _)) EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
.WillOnce([&](const QImage &, const QImage &, const QImage &) { notification.notify(); }); .WillOnce(
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed))) [&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
.WillOnce([&](auto) { notification.notify(); }); EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
.WillOnce([&](auto, auto) { notification.notify(); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -205,12 +209,12 @@ TEST_F(ImageCacheGenerator, abort_callback)
TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort) TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort); abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
}); });
ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _, _)).Times(0); EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _, _)).Times(0);
@@ -222,9 +226,9 @@ TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed) TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
{ {
ON_CALL(collectorMock, start(_, _, _, _, _)) ON_CALL(collectorMock, start(_, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
}); });
EXPECT_CALL( EXPECT_CALL(
@@ -239,13 +243,13 @@ TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
TEST_F(ImageCacheGenerator, abort_for_null_image) TEST_F(ImageCacheGenerator, abort_for_null_image)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}); captureCallback(QImage{}, QImage{}, QImage{}, {});
}); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed))) EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
.WillOnce([&](auto) { notification.notify(); }); .WillOnce([&](auto, auto) { notification.notify(); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -254,13 +258,13 @@ TEST_F(ImageCacheGenerator, abort_for_null_image)
TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null) TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, {}, smallImage1); captureCallback({}, {}, smallImage1, {});
}); });
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1))) EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1), _))
.WillOnce([&](auto, auto, auto) { notification.notify(); }); .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -269,9 +273,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null) TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, {}, smallImage1); captureCallback({}, {}, smallImage1, {});
}); });
EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(QImage()), Eq(smallImage1))) EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(QImage()), Eq(smallImage1)))
@@ -284,13 +288,13 @@ TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null) TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, midSizeImage1, {}); captureCallback({}, midSizeImage1, {}, {});
}); });
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{}))) EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{}), _))
.WillOnce([&](auto, auto, auto) { notification.notify(); }); .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -299,9 +303,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null) TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, midSizeImage1, {}); captureCallback({}, midSizeImage1, {}, {});
}); });
EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(midSizeImage1), Eq(QImage()))) EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(midSizeImage1), Eq(QImage())))
@@ -314,12 +318,13 @@ TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null) TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault( .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); }); captureCallback(image1, {}, {}, {});
});
EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{}))) EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{}), _))
.WillOnce([&](auto, auto, auto) { notification.notify(); }); .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage( generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -328,9 +333,10 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null) TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault( .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); }); captureCallback(image1, {}, {}, {});
});
EXPECT_CALL(storageMock, storeImage(_, _, Eq(image1), Eq(QImage{}), Eq(QImage{}))) EXPECT_CALL(storageMock, storeImage(_, _, Eq(image1), Eq(QImage{}), Eq(QImage{})))
.WillOnce([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillOnce([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -342,9 +348,10 @@ TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty) TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault( .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback({}, {}, {}); }); captureCallback({}, {}, {}, {});
});
EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); }); EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); });
@@ -357,17 +364,16 @@ TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback) TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
{ {
ON_CALL(collectorMock, start(_, _, _, _, _)).WillByDefault([&](auto, auto, auto, auto, auto) { ON_CALL(collectorMock, start(_, _, _, _, _, _))
notification.wait(); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.wait(); });
});
generator.generateImage( generator.generateImage(
"name", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
generator.generateImage( generator.generateImage(
"name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort))) EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort), _))
.Times(AtLeast(1)) .Times(AtLeast(1))
.WillRepeatedly([&](auto) { waitInThread.notify(); }); .WillRepeatedly([&](auto, auto) { waitInThread.notify(); });
generator.clean(); generator.clean();
notification.notify(); notification.notify();
@@ -376,14 +382,14 @@ TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
TEST_F(ImageCacheGenerator, wait_for_finished) TEST_F(ImageCacheGenerator, wait_for_finished)
{ {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
waitInThread.wait(); waitInThread.wait();
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) { .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
generator.generateImage( generator.generateImage(
@@ -391,7 +397,7 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
generator.generateImage( generator.generateImage(
"name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}); "name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
EXPECT_CALL(imageCallbackMock, Call(_, _, _)).Times(AtMost(2)); EXPECT_CALL(imageCallbackMock, Call(_, _, _, _)).Times(AtMost(2));
waitInThread.notify(); waitInThread.notify();
generator.waitForFinished(); generator.waitForFinished();
@@ -399,8 +405,8 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
TEST_F(ImageCacheGenerator, calls_collector_with_extra_id) TEST_F(ImageCacheGenerator, calls_collector_with_extra_id)
{ {
EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", "extraId1", {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name", "extraId1", {}, imageCallbackMock.AsStdFunction(), {}, {});
notification.wait(); notification.wait();
@@ -419,8 +425,9 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
ElementsAre(QSize{20, 11})), ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))), Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_, _,
_,
_)) _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", generator.generateImage("name",
{}, {},
@@ -433,12 +440,12 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
TEST_F(ImageCacheGenerator, merge_tasks) TEST_F(ImageCacheGenerator, merge_tasks)
{ {
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)); EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, {}, {}); generator.generateImage("name", {}, {}, {}, {}, {});
@@ -450,13 +457,13 @@ TEST_F(ImageCacheGenerator, merge_tasks)
TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id) TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
{ {
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, {}, {}); generator.generateImage("name", {}, {}, {}, {}, {});
@@ -467,12 +474,12 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id) TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
{ {
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)); EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", "id1", {}, {}, {}, {}); generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -484,12 +491,12 @@ TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id) TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
{ {
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _)) EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.Times(2) .Times(2)
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", "id1", {}, {}, {}, {}); generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -500,13 +507,13 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged) TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
{ {
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
}); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{4}), _, _, _)); EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{4}), _, _, _));
@@ -521,18 +528,18 @@ TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged) TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
{ {
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> newerImageCallbackMock; NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> newerImageCallbackMock;
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto imageCallback, auto) { .WillByDefault([&](auto, auto, auto, auto imageCallback, auto, auto) {
imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}); imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
}); });
EXPECT_CALL(imageCallbackMock, Call(_, _, _)); EXPECT_CALL(imageCallbackMock, Call(_, _, _, _));
EXPECT_CALL(newerImageCallbackMock, Call(_, _, _)); EXPECT_CALL(newerImageCallbackMock, Call(_, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {}); generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -544,18 +551,18 @@ TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged) TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
{ {
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> newerAbortCallbackMock; NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> newerAbortCallbackMock;
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); }); .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _)) ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
}); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed))); EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _));
EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed))); EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {}); generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, abortCallbackMock.AsStdFunction(), {}); generator.generateImage("name", {}, {}, {}, abortCallbackMock.AsStdFunction(), {});
@@ -567,9 +574,9 @@ TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, dont_call_null_image_callback) TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
{ {
EXPECT_CALL(collectorMock, start(_, _, _, _, _)) EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) { .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(image1, midSizeImage1, smallImage1); captureCallback(image1, midSizeImage1, smallImage1, {});
notification.notify(); notification.notify();
}); });
@@ -579,9 +586,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image) TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
{ {
EXPECT_CALL(collectorMock, start(_, _, _, _, _)) EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) { .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}); captureCallback(QImage{}, QImage{}, QImage{}, {});
notification.notify(); notification.notify();
}); });
@@ -591,9 +598,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
TEST_F(ImageCacheGenerator, dont_call_null_abort_callback) TEST_F(ImageCacheGenerator, dont_call_null_abort_callback)
{ {
EXPECT_CALL(collectorMock, start(_, _, _, _, _)) EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto, auto abortCallback) { .WillOnce([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed); abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify(); notification.notify();
}); });