Actually save the edited calls.

[apitrace] / gui / loaderthread.cpp

diff --git a/gui/loaderthread.cpp b/gui/loaderthread.cpp
index 37898a490ceb49a53dab23edee628087df38ca51..03f0ccd0f68569983d7bc9b0ca362bae23ab8f70 100644 (file)
--- a/gui/loaderthread.cpp
+++ b/gui/loaderthread.cpp
@@ -12,38 +12,20 @@
 
 static ApiTraceCall *
 apiCallFromTraceCall(const Trace::Call *call,
-                     const QHash<QString, QUrl> &helpHash)
+                     const QHash<QString, QUrl> &helpHash,
+                     ApiTraceFrame *frame)
 {
-    ApiTraceCall *apiCall = new ApiTraceCall();
-    apiCall->name = QString::fromStdString(call->sig->name);
-    apiCall->index = call->no;
-
-    QString argumentsText;
-    for (int i = 0; i < call->sig->arg_names.size(); ++i) {
-        apiCall->argNames +=
-            QString::fromStdString(call->sig->arg_names[i]);
-    }
-    if (call->ret) {
-        VariantVisitor retVisitor;
-        call->ret->visit(retVisitor);
-        apiCall->returnValue = retVisitor.variant();
-    }
-    for (int i = 0; i < call->args.size(); ++i) {
-        VariantVisitor argVisitor;
-        call->args[i]->visit(argVisitor);
-        apiCall->argValues += argVisitor.variant();
-    }
+    ApiTraceCall *apiCall = new ApiTraceCall(frame, call);
 
-    apiCall->helpUrl = helpHash.value(apiCall->name);
+    apiCall->setHelpUrl(helpHash.value(apiCall->name()));
 
-    //force generation of the internal state
-    apiCall->filterText();
     return apiCall;
 }
 
-LoaderThread::LoaderThread(QObject *parent)
+LoaderThread::LoaderThread(ApiTrace *parent)
     : QThread(parent),
-      m_frameMarker(ApiTrace::FrameMarker_SwapBuffers)
+      m_frameMarker(ApiTrace::FrameMarker_SwapBuffers),
+      m_trace(parent)
 {
 }
 
@@ -73,29 +55,39 @@ void LoaderThread::run()
     file.close();
 
     Trace::Parser p;
+    QVector<ApiTraceCall*> calls;
+    quint64 binaryDataSize = 0;
     if (p.open(m_fileName.toLatin1().constData())) {
-        Trace::Call *call;
-        call = p.parse_call();
+        Trace::Call *call = p.parse_call();
         while (call) {
             //std::cout << *call;
             if (!currentFrame) {
-                currentFrame = new ApiTraceFrame();
+                currentFrame = new ApiTraceFrame(m_trace);
                 currentFrame->number = frameCount;
                 ++frameCount;
             }
             ApiTraceCall *apiCall =
-                apiCallFromTraceCall(call, helpHash);
-            apiCall->parentFrame = currentFrame;
-            currentFrame->calls.append(apiCall);
+                apiCallFromTraceCall(call, helpHash, currentFrame);
+            calls.append(apiCall);
+            if (apiCall->hasBinaryData()) {
+                QByteArray data =
+                    apiCall->arguments()[apiCall->binaryDataIndex()].toByteArray();
+                binaryDataSize += data.size();
+            }
             if (ApiTrace::isCallAFrameMarker(apiCall,
                                              m_frameMarker)) {
+                calls.squeeze();
+                currentFrame->setCalls(calls, binaryDataSize);
+                calls.clear();
                 frames.append(currentFrame);
                 currentFrame = 0;
+                binaryDataSize = 0;
                 if (frames.count() >= FRAMES_TO_CACHE) {
                     emit parsedFrames(frames);
                     frames.clear();
                 }
             }
+            delete call;
             call = p.parse_call();
         }
     }
@@ -103,6 +95,10 @@ void LoaderThread::run()
     //  it's just a bunch of Delete calls for every object
     //  after the last SwapBuffers
     if (currentFrame) {
+        if (!frames.count()) {
+            calls.squeeze();
+            currentFrame->setCalls(calls, binaryDataSize);
+        }
         frames.append(currentFrame);
         currentFrame = 0;
     }