← Back to branch summary

~phablet-team/qtorganizer5-eds/rtm-14.09

« back to all changes in this revision

Viewing changes to qorganizer/qorganizer-eds-engine.cpp

  • Committer: CI bot
  • Author(s): Renato Araujo Oliveira Filho
  • Date: 2014-05-02 14:24:16 UTC
  • mfrom: (54.1.8 fix-1309186)
  • Revision ID: ps-jenkins@lists.canonical.com-20140502142416-zw41l0pct7m9cicg
Check if request was destroyed by the caller before continue with request process. Fixes: 1309186

Show diffs side-by-side

added added

removed removed

Lines of Context:
qorganizer/qorganizer-eds-engine.cpp
95
95
 
96
96
QOrganizerEDSEngine::~QOrganizerEDSEngine()
97
97
{
98
 
    Q_FOREACH(QOrganizerAbstractRequest *req, m_runningRequests.keys()) {
 
98
    QList<QOrganizerAbstractRequest*> reqs = m_runningRequests.keys();
 
99
    Q_FOREACH(QOrganizerAbstractRequest *req, reqs) {
99
100
        req->cancel();
100
101
    }
101
102
 
130
131
 
131
132
void QOrganizerEDSEngine::itemsAsyncStart(FetchRequestData *data)
132
133
{
 
134
    // check if request was destroyed by the caller
 
135
    if (!data->isLive()) {
 
136
        releaseRequestData(data);
 
137
        return;
 
138
    }
 
139
 
133
140
    QString collection = data->nextCollection();
134
141
    if (!collection.isEmpty()) {
135
142
        EClient *client = data->parent()->d->m_sourceRegistry->client(collection);
154
161
        }
155
162
    } else {
156
163
        data->finish();
157
 
        delete data;
 
164
        releaseRequestData(data);
158
165
    }
159
166
}
160
167
 
161
168
void QOrganizerEDSEngine::itemsAsyncDone(FetchRequestData *data)
162
169
{
163
 
    itemsAsyncStart(data);
 
170
    if (data->isLive()) {
 
171
        itemsAsyncStart(data);
 
172
    } else {
 
173
        releaseRequestData(data);
 
174
    }
164
175
}
165
176
 
166
177
void QOrganizerEDSEngine::itemsAsyncListed(ECalComponent *comp,
171
182
    Q_UNUSED(instanceStart);
172
183
    Q_UNUSED(instanceEnd);
173
184
 
174
 
    icalcomponent *icalComp = icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp));
175
 
    if (icalComp) {
176
 
        data->appendResult(icalComp);
 
185
    if (data->isLive()) {
 
186
        icalcomponent *icalComp = icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp));
 
187
        if (icalComp) {
 
188
            data->appendResult(icalComp);
 
189
        }
177
190
    }
178
191
}
179
192
 
192
205
        qWarning() << "Fail to list events in calendar" << gError->message;
193
206
        g_error_free(gError);
194
207
        gError = 0;
195
 
        data->finish(QOrganizerManager::InvalidCollectionError);
196
 
        delete data;
 
208
        if (data->isLive()) {
 
209
            data->finish(QOrganizerManager::InvalidCollectionError);
 
210
        }
 
211
        releaseRequestData(data);
197
212
        return;
198
 
    } else {
 
213
    }
 
214
 
 
215
    // check if request was destroyed by the caller
 
216
    if (data->isLive()) {
199
217
        data->appendResults(data->parent()->parseEvents(data->collection(), events, false));
 
218
        itemsAsyncStart(data);
 
219
    } else {
 
220
        releaseRequestData(data);
200
221
    }
201
 
    itemsAsyncStart(data);
202
222
}
203
223
 
204
224
void QOrganizerEDSEngine::itemsByIdAsync(QOrganizerItemFetchByIdRequest *req)
209
229
 
210
230
void QOrganizerEDSEngine::itemsByIdAsyncStart(FetchByIdRequestData *data)
211
231
{
 
232
    // check if request was destroyed by the caller
 
233
    if (!data->isLive()) {
 
234
        releaseRequestData(data);
 
235
        return;
 
236
    }
 
237
 
212
238
    QString id = data->nextId();
213
239
    if (!id.isEmpty()) {
214
240
        QStringList ids = id.split("/");
233
259
        }
234
260
    } else if (data->end()) {
235
261
        data->finish();
236
 
        delete data;
 
262
        releaseRequestData(data);
237
263
        return;
238
264
    }
239
265
    qWarning() << "Invalid item id" << id;
254
280
        g_error_free(gError);
255
281
        gError = 0;
256
282
        data->appendResult(QOrganizerItem());
257
 
    } else if (icalComp) {
 
283
    } else if (icalComp && data->isLive()) {
258
284
        GSList *events = g_slist_append(0, icalComp);
259
285
        QList<QOrganizerItem> items = data->parent()->parseEvents(data->currentCollectionId(), events, true);
260
286
        Q_ASSERT(items.size() == 1);
261
287
        data->appendResult(items[0]);
262
288
        g_slist_free_full(events, (GDestroyNotify) icalcomponent_free);
263
289
    }
264
 
    itemsByIdAsyncStart(data);
 
290
 
 
291
    if (data->isLive()) {
 
292
        itemsByIdAsyncStart(data);
 
293
    } else {
 
294
        releaseRequestData(data);
 
295
    }
265
296
}
266
297
 
267
298
void QOrganizerEDSEngine::itemOcurrenceAsync(QOrganizerItemOccurrenceFetchRequest *req)
283
314
    } else {
284
315
        qWarning() << "Fail to find collection:" << req->parentItem().collectionId();
285
316
        data->finish(QOrganizerManager::DoesNotExistError);
286
 
        delete data;
287
 
        return;
 
317
        releaseRequestData(data);
288
318
    }
289
319
}
290
320
 
299
329
    if (error) {
300
330
        qWarning() << "Fail to get object for id:" << data->request<QOrganizerItemOccurrenceFetchRequest>()->parentItem();
301
331
        g_error_free(error);
302
 
        data->finish(QOrganizerManager::DoesNotExistError);
303
 
        delete data;
 
332
        if (data->isLive()) {
 
333
            data->finish(QOrganizerManager::DoesNotExistError);
 
334
        }
 
335
        releaseRequestData(data);
304
336
        return;
305
337
    }
306
338
 
307
 
    e_cal_client_generate_instances_for_object(data->client(),
308
 
                                               comp,
309
 
                                               data->startDate(),
310
 
                                               data->endDate(),
311
 
                                               data->cancellable(),
312
 
                                               (ECalRecurInstanceFn) QOrganizerEDSEngine::itemOcurrenceAsyncListed,
313
 
                                               data,
314
 
                                               (GDestroyNotify) QOrganizerEDSEngine::itemOcurrenceAsyncDone);
 
339
    if (data->isLive()) {
 
340
        e_cal_client_generate_instances_for_object(data->client(),
 
341
                                                   comp,
 
342
                                                   data->startDate(),
 
343
                                                   data->endDate(),
 
344
                                                   data->cancellable(),
 
345
                                                   (ECalRecurInstanceFn) QOrganizerEDSEngine::itemOcurrenceAsyncListed,
 
346
                                                   data,
 
347
                                                   (GDestroyNotify) QOrganizerEDSEngine::itemOcurrenceAsyncDone);
 
348
    } else {
 
349
        releaseRequestData(data);
 
350
    }
315
351
}
316
352
 
317
353
void QOrganizerEDSEngine::itemOcurrenceAsyncListed(ECalComponent *comp,
322
358
    Q_UNUSED(instanceStart);
323
359
    Q_UNUSED(instanceEnd);
324
360
 
 
361
    // check if request was destroyed by the caller
 
362
    if (!data->isLive()) {
 
363
        releaseRequestData(data);
 
364
        return;
 
365
    }
 
366
 
325
367
    icalcomponent *icalComp = icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp));
326
368
    if (icalComp) {
327
369
        data->appendResult(icalComp);
330
372
 
331
373
void QOrganizerEDSEngine::itemOcurrenceAsyncDone(FetchOcurrenceData *data)
332
374
{
333
 
    data->finish();
334
 
    delete data;
 
375
    if (data->isLive()) {
 
376
        data->finish();
 
377
    }
 
378
    releaseRequestData(data);
335
379
}
336
380
 
337
381
QList<QOrganizerItem> QOrganizerEDSEngine::items(const QList<QOrganizerItemId> &itemIds,
456
500
 
457
501
void QOrganizerEDSEngine::saveItemsAsyncStart(SaveRequestData *data)
458
502
{
 
503
    // check if request was destroyed by the caller
 
504
    if (!data->isLive()) {
 
505
        releaseRequestData(data);
 
506
        return;
 
507
    }
 
508
 
459
509
    QString collectionId = data->nextCollection();
460
510
 
461
511
    if (collectionId.isNull() && data->end()) {
462
512
        data->finish();
463
 
        delete data;
 
513
        releaseRequestData(data);
464
514
        return;
465
515
    } else {
466
516
        bool createItems = true;
537
587
    Q_UNUSED(source_object);
538
588
 
539
589
    GError *gError = 0;
540
 
    gboolean result = e_cal_client_modify_objects_finish(E_CAL_CLIENT(data->client()),
 
590
    e_cal_client_modify_objects_finish(E_CAL_CLIENT(data->client()),
541
591
                                       res,
542
592
                                       &gError);
543
593
 
544
 
    QCoreApplication::processEvents();
545
 
 
546
594
    if (gError) {
547
595
        qWarning() << "Fail to modify items" << gError->message;
548
596
        g_error_free(gError);
549
597
        gError = 0;
550
 
        Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
551
 
            data->appendResult(i, QOrganizerManager::UnspecifiedError);
 
598
        if (data->isLive()) {
 
599
            Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
 
600
                data->appendResult(i, QOrganizerManager::UnspecifiedError);
 
601
            }
552
602
        }
553
 
    } else {
 
603
    } else if (data->isLive()) {
554
604
        data->appendResults(data->workingItems());
555
605
    }
556
606
 
557
 
    saveItemsAsyncStart(data);
 
607
    if (data->isLive()) {
 
608
        saveItemsAsyncStart(data);
 
609
    } else {
 
610
        releaseRequestData(data);
 
611
    }
558
612
}
559
613
 
560
614
void QOrganizerEDSEngine::saveItemsAsyncCreated(GObject *source_object,
569
623
                                       res,
570
624
                                       &uids,
571
625
                                       &gError);
572
 
    QCoreApplication::processEvents();
573
626
    if (gError) {
574
627
        qWarning() << "Fail to create items:" << gError->message;
575
628
        g_error_free(gError);
576
629
        gError = 0;
577
630
 
578
 
        Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
579
 
            data->appendResult(i, QOrganizerManager::UnspecifiedError);
 
631
        if (data->isLive()) {
 
632
            Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
 
633
                data->appendResult(i, QOrganizerManager::UnspecifiedError);
 
634
            }
580
635
        }
581
 
    } else {
 
636
    } else if (data->isLive()) {
582
637
        QString currentCollectionId = data->currentCollection();
583
638
        if (currentCollectionId.isEmpty()) {
584
639
            currentCollectionId = data->parent()->defaultCollection(0).id().toString();
600
655
        data->appendResults(items);
601
656
    }
602
657
 
603
 
    saveItemsAsyncStart(data);
 
658
    // check if request was destroyed by the caller
 
659
    if (data->isLive()) {
 
660
        saveItemsAsyncStart(data);
 
661
    } else {
 
662
        releaseRequestData(data);
 
663
    }
604
664
}
605
665
 
606
666
bool QOrganizerEDSEngine::saveItems(QList<QtOrganizer::QOrganizerItem> *items,
639
699
 
640
700
void QOrganizerEDSEngine::removeItemsByIdAsyncStart(RemoveByIdRequestData *data)
641
701
{
 
702
    // check if request was destroyed by the caller
 
703
    if (!data->isLive()) {
 
704
        releaseRequestData(data);
 
705
        return;
 
706
    }
 
707
 
642
708
    QString collectionId = data->next();
643
709
    for(; !collectionId.isNull(); collectionId = data->next()) {
644
710
        EClient *client = data->parent()->d->m_sourceRegistry->client(collectionId);
647
713
        GSList *ids = data->compIds();
648
714
        GError *gError = 0;
649
715
        e_cal_client_remove_objects_sync(data->client(), ids, E_CAL_OBJ_MOD_THIS, 0, 0);
650
 
        QCoreApplication::processEvents();
651
716
        if (gError) {
652
717
            qWarning() << "Fail to remove Items" << gError->message;
653
718
            g_error_free(gError);
656
721
        data->commit();
657
722
    }
658
723
    data->finish();
659
 
    delete data;
 
724
    releaseRequestData(data);
660
725
}
661
726
 
662
727
void QOrganizerEDSEngine::removeItemsAsync(QOrganizerItemRemoveRequest *req)
675
740
 
676
741
void QOrganizerEDSEngine::removeItemsAsyncStart(RemoveRequestData *data)
677
742
{
 
743
    // check if request was destroyed by the caller
 
744
    if (!data->isLive()) {
 
745
        releaseRequestData(data);
 
746
        return;
 
747
    }
 
748
 
678
749
    QOrganizerCollectionId collection = data->next();
679
750
    for(; !collection.isNull(); collection = data->next()) {
680
751
        EClient *client = data->parent()->d->m_sourceRegistry->client(collection.toString());
683
754
        GSList *ids = data->compIds();
684
755
        GError *gError = 0;
685
756
        e_cal_client_remove_objects_sync(data->client(), ids, E_CAL_OBJ_MOD_THIS, 0, 0);
686
 
        QCoreApplication::processEvents();
687
757
        if (gError) {
688
758
            qWarning() << "Fail to remove Items" << gError->message;
689
759
            g_error_free(gError);
692
762
        data->commit();
693
763
    }
694
764
    data->finish();
695
 
    delete data;
 
765
    releaseRequestData(data);
696
766
}
697
767
 
698
768
bool QOrganizerEDSEngine::removeItems(const QList<QOrganizerItemId> &itemIds,
801
871
{
802
872
    GError *gError = 0;
803
873
    e_source_registry_create_sources_finish(registry, res, &gError);
 
874
    // WORKAROUND:
 
875
    // avoid return immediately after create the source, because EDS is not ready to write on the source
804
876
    QCoreApplication::processEvents();
805
 
 
806
877
    if (gError) {
807
878
        qWarning() << "Fail to create sources:" << gError->message;
808
879
        g_error_free(gError);
809
 
        data->finish(QOrganizerManager::InvalidCollectionError);
810
 
        delete data;
811
 
    } else {
 
880
        if (data->isLive()) {
 
881
            data->finish(QOrganizerManager::InvalidCollectionError);
 
882
            releaseRequestData(data);
 
883
            return;
 
884
        }
 
885
    } else if (data->isLive()) {
812
886
        data->commitSourceCreated();
813
887
        data->prepareToUpdate();
814
888
        saveCollectionUpdateAsyncStart(data);
817
891
 
818
892
void QOrganizerEDSEngine::saveCollectionUpdateAsyncStart(SaveCollectionRequestData *data)
819
893
{
 
894
    // check if request was destroyed by the caller
 
895
    if (!data->isLive()) {
 
896
        releaseRequestData(data);
 
897
        return;
 
898
    }
 
899
 
820
900
    ESource *source = data->nextSourceToUpdate();
821
901
    if (source) {
822
 
        e_source_registry_commit_source(data->registry(),
823
 
                                        source,
824
 
                                        data->cancellable(),
825
 
                                        (GAsyncReadyCallback) QOrganizerEDSEngine::saveCollectionUpdateAsynCommited,
826
 
                                        data);
 
902
        e_source_write(source,
 
903
                       data->cancellable(),
 
904
                       (GAsyncReadyCallback) QOrganizerEDSEngine::saveCollectionUpdateAsynCommited,
 
905
                       data);
827
906
    } else {
828
907
        data->finish();
829
 
        delete data;
 
908
        releaseRequestData(data);
830
909
    }
831
910
}
832
911
 
833
 
void QOrganizerEDSEngine::saveCollectionUpdateAsynCommited(ESourceRegistry *registry,
 
912
void QOrganizerEDSEngine::saveCollectionUpdateAsynCommited(ESource *source,
834
913
                                                           GAsyncResult *res,
835
914
                                                           SaveCollectionRequestData *data)
836
915
{
837
916
    GError *gError = 0;
838
 
    ESource *currentSource = data->nextSourceToUpdate();
839
 
 
840
 
    e_source_registry_commit_source_finish(registry, res, &gError);
841
 
    QCoreApplication::processEvents();
842
 
 
 
917
 
 
918
    e_source_write_finish(source, res, &gError);
843
919
    if (gError) {
844
920
        qWarning() << "Fail to update collection" << gError->message;
845
921
        g_error_free(gError);
846
 
        data->commitSourceUpdated(currentSource, QOrganizerManager::InvalidCollectionError);
 
922
        if (data->isLive()) {
 
923
            data->commitSourceUpdated(source, QOrganizerManager::InvalidCollectionError);
 
924
        }
 
925
    } else if (data->isLive()) {
 
926
        data->commitSourceUpdated(source);
 
927
    }
 
928
 
 
929
    if (data->isLive()) {
 
930
        saveCollectionUpdateAsyncStart(data);
847
931
    } else {
848
 
        data->commitSourceUpdated(currentSource);
 
932
        releaseRequestData(data);
849
933
    }
850
 
 
851
 
    saveCollectionUpdateAsyncStart(data);
852
934
}
853
935
 
854
936
bool QOrganizerEDSEngine::removeCollection(const QOrganizerCollectionId& collectionId, QOrganizerManager::Error* error)
881
963
                                                     GAsyncResult *res,
882
964
                                                     RemoveCollectionRequestData *data)
883
965
{
 
966
    // check if request was destroyed by the caller
 
967
    if (!data->isLive()) {
 
968
        releaseRequestData(data);
 
969
        return;
 
970
    }
 
971
 
884
972
    if (sourceObject && res) {
885
973
        GError *gError = 0;
886
974
        if (data->remoteDeletable()) {
888
976
        } else {
889
977
            e_source_remove_finish(E_SOURCE(sourceObject), res, &gError);
890
978
        }
891
 
        QCoreApplication::processEvents();
892
979
        if (gError) {
893
980
            qWarning() << "Fail to remove collection" << gError->message;
894
981
            g_error_free(gError);
915
1002
        }
916
1003
    } else {
917
1004
        data->finish();
 
1005
        releaseRequestData(data);
 
1006
    }
 
1007
}
 
1008
 
 
1009
void QOrganizerEDSEngine::releaseRequestData(RequestData *data)
 
1010
{
 
1011
    if (data->cancelled()) {
 
1012
        // if request was cancelled data will be destroyed later
 
1013
        data->continueCancel();
 
1014
    } else {
918
1015
        delete data;
919
1016
    }
920
1017
}
923
1020
{
924
1021
    RequestData *data = m_runningRequests.take(req);
925
1022
    if (data) {
 
1023
        data->cancel();
926
1024
        delete data;
927
1025
    }
928
1026
}