1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "mozilla/TransactionManager.h"
7
8 #include "mozilla/Assertions.h"
9 #include "mozilla/mozalloc.h"
10 #include "mozilla/TransactionStack.h"
11 #include "nsCOMPtr.h"
12 #include "nsDebug.h"
13 #include "nsError.h"
14 #include "nsISupportsBase.h"
15 #include "nsISupportsUtils.h"
16 #include "nsITransaction.h"
17 #include "nsITransactionListener.h"
18 #include "nsIWeakReference.h"
19 #include "TransactionItem.h"
20
21 namespace mozilla {
22
TransactionManager(int32_t aMaxTransactionCount)23 TransactionManager::TransactionManager(int32_t aMaxTransactionCount)
24 : mMaxTransactionCount(aMaxTransactionCount),
25 mDoStack(TransactionStack::FOR_UNDO),
26 mUndoStack(TransactionStack::FOR_UNDO),
27 mRedoStack(TransactionStack::FOR_REDO) {}
28
29 NS_IMPL_CYCLE_COLLECTION_CLASS(TransactionManager)
30
31 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TransactionManager)
32 NS_IMPL_CYCLE_COLLECTION_UNLINK(mListeners)
33 tmp->mDoStack.DoUnlink();
34 tmp->mUndoStack.DoUnlink();
35 tmp->mRedoStack.DoUnlink();
36 NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
37 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
38
39 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TransactionManager)
40 NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListeners)
41 tmp->mDoStack.DoTraverse(cb);
42 tmp->mUndoStack.DoTraverse(cb);
43 tmp->mRedoStack.DoTraverse(cb);
44 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
45
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransactionManager)46 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransactionManager)
47 NS_INTERFACE_MAP_ENTRY(nsITransactionManager)
48 NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
49 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITransactionManager)
50 NS_INTERFACE_MAP_END
51
52 NS_IMPL_CYCLE_COLLECTING_ADDREF(TransactionManager)
53 NS_IMPL_CYCLE_COLLECTING_RELEASE(TransactionManager)
54
55 NS_IMETHODIMP TransactionManager::DoTransaction(nsITransaction* aTransaction) {
56 if (NS_WARN_IF(!aTransaction)) {
57 return NS_ERROR_INVALID_ARG;
58 }
59
60 bool doInterrupt = false;
61
62 nsresult rv = WillDoNotify(aTransaction, &doInterrupt);
63 if (NS_FAILED(rv)) {
64 NS_WARNING("TransactionManager::WillDoNotify() failed");
65 return rv;
66 }
67 if (doInterrupt) {
68 return NS_OK;
69 }
70
71 rv = BeginTransaction(aTransaction, nullptr);
72 if (NS_FAILED(rv)) {
73 NS_WARNING("TransactionManager::BeginTransaction() failed");
74 DebugOnly<nsresult> rvIgnored = DidDoNotify(aTransaction, rv);
75 NS_WARNING_ASSERTION(
76 NS_SUCCEEDED(rvIgnored),
77 "TransactionManager::DidDoNotify() failed, but ignored");
78 return rv;
79 }
80
81 rv = EndTransaction(false);
82 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
83 "TransactionManager::EndTransaction() failed");
84
85 nsresult rv2 = DidDoNotify(aTransaction, rv);
86 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
87 "TransactionManager::DidDoNotify() failed");
88
89 // XXX The result of EndTransaction() or DidDoNotify() if EndTransaction()
90 // succeeded.
91 return NS_SUCCEEDED(rv) ? rv2 : rv;
92 }
93
UndoTransaction()94 NS_IMETHODIMP TransactionManager::UndoTransaction() { return Undo(); }
95
Undo()96 nsresult TransactionManager::Undo() {
97 // It's possible to be called Undo() again while the transaction manager is
98 // executing a transaction's DoTransaction() method. If this happens,
99 // the Undo() request is ignored, and we return NS_ERROR_FAILURE. This
100 // may occur if a mutation event listener calls document.execCommand("undo").
101 if (NS_WARN_IF(!mDoStack.IsEmpty())) {
102 return NS_ERROR_FAILURE;
103 }
104
105 // Peek at the top of the undo stack. Don't remove the transaction
106 // until it has successfully completed.
107 RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
108 if (!transactionItem) {
109 // Bail if there's nothing on the stack.
110 return NS_OK;
111 }
112
113 nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
114 bool doInterrupt = false;
115 nsresult rv = WillUndoNotify(transaction, &doInterrupt);
116 if (NS_FAILED(rv)) {
117 NS_WARNING("TransactionManager::WillUndoNotify() failed");
118 return rv;
119 }
120 if (doInterrupt) {
121 return NS_OK;
122 }
123
124 rv = transactionItem->UndoTransaction(this);
125 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
126 "TransactionItem::UndoTransaction() failed");
127 if (NS_SUCCEEDED(rv)) {
128 transactionItem = mUndoStack.Pop();
129 mRedoStack.Push(transactionItem.forget());
130 }
131
132 nsresult rv2 = DidUndoNotify(transaction, rv);
133 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
134 "TransactionManager::DidUndoNotify() failed");
135
136 // XXX The result of UndoTransaction() or DidUndoNotify() if UndoTransaction()
137 // succeeded.
138 return NS_SUCCEEDED(rv) ? rv2 : rv;
139 }
140
RedoTransaction()141 NS_IMETHODIMP TransactionManager::RedoTransaction() { return Redo(); }
142
Redo()143 nsresult TransactionManager::Redo() {
144 // It's possible to be called Redo() again while the transaction manager is
145 // executing a transaction's DoTransaction() method. If this happens,
146 // the Redo() request is ignored, and we return NS_ERROR_FAILURE. This
147 // may occur if a mutation event listener calls document.execCommand("redo").
148 if (NS_WARN_IF(!mDoStack.IsEmpty())) {
149 return NS_ERROR_FAILURE;
150 }
151
152 // Peek at the top of the redo stack. Don't remove the transaction
153 // until it has successfully completed.
154 RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
155 if (!transactionItem) {
156 // Bail if there's nothing on the stack.
157 return NS_OK;
158 }
159
160 nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
161 bool doInterrupt = false;
162 nsresult rv = WillRedoNotify(transaction, &doInterrupt);
163 if (NS_FAILED(rv)) {
164 NS_WARNING("TransactionManager::WillRedoNotify() failed");
165 return rv;
166 }
167 if (doInterrupt) {
168 return NS_OK;
169 }
170
171 rv = transactionItem->RedoTransaction(this);
172 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
173 "TransactionItem::RedoTransaction() failed");
174 if (NS_SUCCEEDED(rv)) {
175 transactionItem = mRedoStack.Pop();
176 mUndoStack.Push(transactionItem.forget());
177 }
178
179 nsresult rv2 = DidRedoNotify(transaction, rv);
180 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
181 "TransactionManager::DidRedoNotify() failed");
182
183 // XXX The result of RedoTransaction() or DidRedoNotify() if RedoTransaction()
184 // succeeded.
185 return NS_SUCCEEDED(rv) ? rv2 : rv;
186 }
187
Clear()188 NS_IMETHODIMP TransactionManager::Clear() {
189 return NS_WARN_IF(!ClearUndoRedo()) ? NS_ERROR_FAILURE : NS_OK;
190 }
191
BeginBatch(nsISupports * aData)192 NS_IMETHODIMP TransactionManager::BeginBatch(nsISupports* aData) {
193 nsresult rv = BeginBatchInternal(aData);
194 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
195 "TransactionManager::BeginBatchInternal() failed");
196 return rv;
197 }
198
BeginBatchInternal(nsISupports * aData)199 nsresult TransactionManager::BeginBatchInternal(nsISupports* aData) {
200 // We can batch independent transactions together by simply pushing
201 // a dummy transaction item on the do stack. This dummy transaction item
202 // will be popped off the do stack, and then pushed on the undo stack
203 // in EndBatch().
204 bool doInterrupt = false;
205 nsresult rv = WillBeginBatchNotify(&doInterrupt);
206 if (NS_FAILED(rv)) {
207 NS_WARNING("TransactionManager::WillBeginBatchNotify() failed");
208 return rv;
209 }
210 if (doInterrupt) {
211 return NS_OK;
212 }
213
214 rv = BeginTransaction(nullptr, aData);
215 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
216 "TransactionManager::BeginTransaction() failed");
217
218 nsresult rv2 = DidBeginBatchNotify(rv);
219 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
220 "TransactionManager::DidBeginBatchNotify() failed");
221
222 // XXX The result of BeginTransaction() or DidBeginBatchNotify() if
223 // BeginTransaction() succeeded.
224 return NS_SUCCEEDED(rv) ? rv2 : rv;
225 }
226
EndBatch(bool aAllowEmpty)227 NS_IMETHODIMP TransactionManager::EndBatch(bool aAllowEmpty) {
228 nsresult rv = EndBatchInternal(aAllowEmpty);
229 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
230 "TransactionManager::EndBatchInternal() failed");
231 return rv;
232 }
233
EndBatchInternal(bool aAllowEmpty)234 nsresult TransactionManager::EndBatchInternal(bool aAllowEmpty) {
235 // XXX: Need to add some mechanism to detect the case where the transaction
236 // at the top of the do stack isn't the dummy transaction, so we can
237 // throw an error!! This can happen if someone calls EndBatch() within
238 // the DoTransaction() method of a transaction.
239 //
240 // For now, we can detect this case by checking the value of the
241 // dummy transaction's mTransaction field. If it is our dummy
242 // transaction, it should be nullptr. This may not be true in the
243 // future when we allow users to execute a transaction when beginning
244 // a batch!!!!
245 RefPtr<TransactionItem> transactionItem = mDoStack.Peek();
246 if (NS_WARN_IF(!transactionItem)) {
247 return NS_ERROR_FAILURE;
248 }
249 nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
250 if (NS_WARN_IF(transaction)) {
251 return NS_ERROR_FAILURE;
252 }
253
254 bool doInterrupt = false;
255 nsresult rv = WillEndBatchNotify(&doInterrupt);
256 if (NS_FAILED(rv)) {
257 NS_WARNING("TransactionManager::WillEndBatchNotify() failed");
258 return rv;
259 }
260 if (doInterrupt) {
261 return NS_OK;
262 }
263
264 rv = EndTransaction(aAllowEmpty);
265 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
266 "TransactionManager::EndTransaction() failed");
267
268 nsresult rv2 = DidEndBatchNotify(rv);
269 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
270 "TransactionManager::DidEndBatchNotify() failed");
271
272 // XXX The result of EndTransaction() or DidEndBatchNotify() if
273 // EndTransaction() succeeded.
274 return NS_SUCCEEDED(rv) ? rv2 : rv;
275 }
276
GetNumberOfUndoItems(int32_t * aNumItems)277 NS_IMETHODIMP TransactionManager::GetNumberOfUndoItems(int32_t* aNumItems) {
278 *aNumItems = static_cast<int32_t>(NumberOfUndoItems());
279 MOZ_ASSERT(*aNumItems >= 0);
280 return NS_OK;
281 }
282
GetNumberOfRedoItems(int32_t * aNumItems)283 NS_IMETHODIMP TransactionManager::GetNumberOfRedoItems(int32_t* aNumItems) {
284 *aNumItems = static_cast<int32_t>(NumberOfRedoItems());
285 MOZ_ASSERT(*aNumItems >= 0);
286 return NS_OK;
287 }
288
GetMaxTransactionCount(int32_t * aMaxCount)289 NS_IMETHODIMP TransactionManager::GetMaxTransactionCount(int32_t* aMaxCount) {
290 if (NS_WARN_IF(!aMaxCount)) {
291 return NS_ERROR_INVALID_ARG;
292 }
293 *aMaxCount = mMaxTransactionCount;
294 return NS_OK;
295 }
296
SetMaxTransactionCount(int32_t aMaxCount)297 NS_IMETHODIMP TransactionManager::SetMaxTransactionCount(int32_t aMaxCount) {
298 return NS_WARN_IF(!EnableUndoRedo(aMaxCount)) ? NS_ERROR_FAILURE : NS_OK;
299 }
300
EnableUndoRedo(int32_t aMaxTransactionCount)301 bool TransactionManager::EnableUndoRedo(int32_t aMaxTransactionCount) {
302 // It is illegal to call EnableUndoRedo() while the transaction manager is
303 // executing a transaction's DoTransaction() method because the undo and redo
304 // stacks might get pruned. If this happens, the EnableUndoRedo() request is
305 // ignored, and we return false.
306 if (NS_WARN_IF(!mDoStack.IsEmpty())) {
307 return false;
308 }
309
310 // If aMaxTransactionCount is 0, it means to disable undo/redo.
311 if (!aMaxTransactionCount) {
312 mUndoStack.Clear();
313 mRedoStack.Clear();
314 mMaxTransactionCount = 0;
315 return true;
316 }
317
318 // If aMaxTransactionCount is less than zero, the user wants unlimited
319 // levels of undo! No need to prune the undo or redo stacks.
320 if (aMaxTransactionCount < 0) {
321 mMaxTransactionCount = -1;
322 return true;
323 }
324
325 // If new max transaction count is greater than or equal to current max
326 // transaction count, we don't need to remove any transactions.
327 if (mMaxTransactionCount >= 0 &&
328 mMaxTransactionCount <= aMaxTransactionCount) {
329 mMaxTransactionCount = aMaxTransactionCount;
330 return true;
331 }
332
333 // If aMaxTransactionCount is greater than the number of transactions that
334 // currently exist on the undo and redo stack, there is no need to prune the
335 // undo or redo stacks.
336 size_t numUndoItems = NumberOfUndoItems();
337 size_t numRedoItems = NumberOfRedoItems();
338 size_t total = numUndoItems + numRedoItems;
339 size_t newMaxTransactionCount = static_cast<size_t>(aMaxTransactionCount);
340 if (newMaxTransactionCount > total) {
341 mMaxTransactionCount = aMaxTransactionCount;
342 return true;
343 }
344
345 // Try getting rid of some transactions on the undo stack! Start at
346 // the bottom of the stack and pop towards the top.
347 for (; numUndoItems && (numRedoItems + numUndoItems) > newMaxTransactionCount;
348 numUndoItems--) {
349 RefPtr<TransactionItem> transactionItem = mUndoStack.PopBottom();
350 MOZ_ASSERT(transactionItem);
351 }
352
353 // If necessary, get rid of some transactions on the redo stack! Start at
354 // the bottom of the stack and pop towards the top.
355 for (; numRedoItems && (numRedoItems + numUndoItems) > newMaxTransactionCount;
356 numRedoItems--) {
357 RefPtr<TransactionItem> transactionItem = mRedoStack.PopBottom();
358 MOZ_ASSERT(transactionItem);
359 }
360
361 mMaxTransactionCount = aMaxTransactionCount;
362 return true;
363 }
364
PeekUndoStack(nsITransaction ** aTransaction)365 NS_IMETHODIMP TransactionManager::PeekUndoStack(nsITransaction** aTransaction) {
366 MOZ_ASSERT(aTransaction);
367 *aTransaction = PeekUndoStack().take();
368 return NS_OK;
369 }
370
PeekUndoStack()371 already_AddRefed<nsITransaction> TransactionManager::PeekUndoStack() {
372 RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
373 if (!transactionItem) {
374 return nullptr;
375 }
376 return transactionItem->GetTransaction();
377 }
378
PeekRedoStack(nsITransaction ** aTransaction)379 NS_IMETHODIMP TransactionManager::PeekRedoStack(nsITransaction** aTransaction) {
380 MOZ_ASSERT(aTransaction);
381 *aTransaction = PeekRedoStack().take();
382 return NS_OK;
383 }
384
PeekRedoStack()385 already_AddRefed<nsITransaction> TransactionManager::PeekRedoStack() {
386 RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
387 if (!transactionItem) {
388 return nullptr;
389 }
390 return transactionItem->GetTransaction();
391 }
392
BatchTopUndo()393 nsresult TransactionManager::BatchTopUndo() {
394 if (mUndoStack.GetSize() < 2) {
395 // Not enough transactions to merge into one batch.
396 return NS_OK;
397 }
398
399 RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
400 MOZ_ASSERT(lastUndo, "There should be at least two transactions.");
401
402 RefPtr<TransactionItem> previousUndo = mUndoStack.Peek();
403 MOZ_ASSERT(previousUndo, "There should be at least two transactions.");
404
405 nsresult rv = previousUndo->AddChild(*lastUndo);
406 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "TransactionItem::AddChild() failed");
407
408 // Transfer data from the transactions that is going to be
409 // merged to the transaction that it is being merged with.
410 nsCOMArray<nsISupports>& lastData = lastUndo->GetData();
411 nsCOMArray<nsISupports>& previousData = previousUndo->GetData();
412 if (!previousData.AppendObjects(lastData)) {
413 NS_WARNING("nsISupports::AppendObjects() failed");
414 return NS_ERROR_FAILURE;
415 }
416 lastData.Clear();
417 return rv;
418 }
419
RemoveTopUndo()420 nsresult TransactionManager::RemoveTopUndo() {
421 if (mUndoStack.IsEmpty()) {
422 return NS_OK;
423 }
424
425 RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
426 return NS_OK;
427 }
428
AddListener(nsITransactionListener * aListener)429 NS_IMETHODIMP TransactionManager::AddListener(
430 nsITransactionListener* aListener) {
431 if (NS_WARN_IF(!aListener)) {
432 return NS_ERROR_INVALID_ARG;
433 }
434 return NS_WARN_IF(!AddTransactionListener(*aListener)) ? NS_ERROR_FAILURE
435 : NS_OK;
436 }
437
RemoveListener(nsITransactionListener * aListener)438 NS_IMETHODIMP TransactionManager::RemoveListener(
439 nsITransactionListener* aListener) {
440 if (NS_WARN_IF(!aListener)) {
441 return NS_ERROR_INVALID_ARG;
442 }
443 return NS_WARN_IF(!RemoveTransactionListener(*aListener)) ? NS_ERROR_FAILURE
444 : NS_OK;
445 }
446
ClearUndoStack()447 NS_IMETHODIMP TransactionManager::ClearUndoStack() {
448 if (NS_WARN_IF(!mDoStack.IsEmpty())) {
449 return NS_ERROR_FAILURE;
450 }
451 mUndoStack.Clear();
452 return NS_OK;
453 }
454
ClearRedoStack()455 NS_IMETHODIMP TransactionManager::ClearRedoStack() {
456 if (NS_WARN_IF(!mDoStack.IsEmpty())) {
457 return NS_ERROR_FAILURE;
458 }
459 mRedoStack.Clear();
460 return NS_OK;
461 }
462
WillDoNotify(nsITransaction * aTransaction,bool * aInterrupt)463 nsresult TransactionManager::WillDoNotify(nsITransaction* aTransaction,
464 bool* aInterrupt) {
465 nsCOMArray<nsITransactionListener> listeners(mListeners);
466 for (nsITransactionListener* listener : listeners) {
467 if (NS_WARN_IF(!listener)) {
468 return NS_ERROR_FAILURE;
469 }
470 nsresult rv = listener->WillDo(this, aTransaction, aInterrupt);
471 if (NS_FAILED(rv)) {
472 NS_WARNING("nsITransactionListener::WillDo() failed");
473 return rv;
474 }
475 if (*aInterrupt) {
476 return NS_OK;
477 }
478 }
479 return NS_OK;
480 }
481
DidDoNotify(nsITransaction * aTransaction,nsresult aDoResult)482 nsresult TransactionManager::DidDoNotify(nsITransaction* aTransaction,
483 nsresult aDoResult) {
484 nsCOMArray<nsITransactionListener> listeners(mListeners);
485 for (nsITransactionListener* listener : listeners) {
486 if (NS_WARN_IF(!listener)) {
487 return NS_ERROR_FAILURE;
488 }
489 nsresult rv = listener->DidDo(this, aTransaction, aDoResult);
490 if (NS_FAILED(rv)) {
491 NS_WARNING("nsITransactionListener::DidDo() failed");
492 return rv;
493 }
494 }
495 return NS_OK;
496 }
497
WillUndoNotify(nsITransaction * aTransaction,bool * aInterrupt)498 nsresult TransactionManager::WillUndoNotify(nsITransaction* aTransaction,
499 bool* aInterrupt) {
500 nsCOMArray<nsITransactionListener> listeners(mListeners);
501 for (nsITransactionListener* listener : listeners) {
502 if (NS_WARN_IF(!listener)) {
503 return NS_ERROR_FAILURE;
504 }
505 nsresult rv = listener->WillUndo(this, aTransaction, aInterrupt);
506 if (NS_FAILED(rv)) {
507 NS_WARNING("nsITransactionListener::WillUndo() failed");
508 return rv;
509 }
510 if (*aInterrupt) {
511 return NS_OK;
512 }
513 }
514 return NS_OK;
515 }
516
DidUndoNotify(nsITransaction * aTransaction,nsresult aUndoResult)517 nsresult TransactionManager::DidUndoNotify(nsITransaction* aTransaction,
518 nsresult aUndoResult) {
519 nsCOMArray<nsITransactionListener> listeners(mListeners);
520 for (nsITransactionListener* listener : listeners) {
521 if (NS_WARN_IF(!listener)) {
522 return NS_ERROR_FAILURE;
523 }
524 nsresult rv = listener->DidUndo(this, aTransaction, aUndoResult);
525 if (NS_FAILED(rv)) {
526 NS_WARNING("nsITransactionListener::DidUndo() failed");
527 return rv;
528 }
529 }
530 return NS_OK;
531 }
532
WillRedoNotify(nsITransaction * aTransaction,bool * aInterrupt)533 nsresult TransactionManager::WillRedoNotify(nsITransaction* aTransaction,
534 bool* aInterrupt) {
535 nsCOMArray<nsITransactionListener> listeners(mListeners);
536 for (nsITransactionListener* listener : listeners) {
537 if (NS_WARN_IF(!listener)) {
538 return NS_ERROR_FAILURE;
539 }
540 nsresult rv = listener->WillRedo(this, aTransaction, aInterrupt);
541 if (NS_FAILED(rv)) {
542 NS_WARNING("nsITransactionListener::WillRedo() failed");
543 return rv;
544 }
545 if (*aInterrupt) {
546 return NS_OK;
547 }
548 }
549 return NS_OK;
550 }
551
DidRedoNotify(nsITransaction * aTransaction,nsresult aRedoResult)552 nsresult TransactionManager::DidRedoNotify(nsITransaction* aTransaction,
553 nsresult aRedoResult) {
554 nsCOMArray<nsITransactionListener> listeners(mListeners);
555 for (nsITransactionListener* listener : listeners) {
556 if (NS_WARN_IF(!listener)) {
557 return NS_ERROR_FAILURE;
558 }
559 nsresult rv = listener->DidRedo(this, aTransaction, aRedoResult);
560 if (NS_FAILED(rv)) {
561 NS_WARNING("nsITransactionListener::DidRedo() failed");
562 return rv;
563 }
564 }
565 return NS_OK;
566 }
567
WillBeginBatchNotify(bool * aInterrupt)568 nsresult TransactionManager::WillBeginBatchNotify(bool* aInterrupt) {
569 nsCOMArray<nsITransactionListener> listeners(mListeners);
570 for (nsITransactionListener* listener : listeners) {
571 if (NS_WARN_IF(!listener)) {
572 return NS_ERROR_FAILURE;
573 }
574 nsresult rv = listener->WillBeginBatch(this, aInterrupt);
575 if (NS_FAILED(rv)) {
576 NS_WARNING("nsITransactionListener::WillBeginBatch() failed");
577 return rv;
578 }
579 if (*aInterrupt) {
580 return NS_OK;
581 }
582 }
583 return NS_OK;
584 }
585
DidBeginBatchNotify(nsresult aResult)586 nsresult TransactionManager::DidBeginBatchNotify(nsresult aResult) {
587 nsCOMArray<nsITransactionListener> listeners(mListeners);
588 for (nsITransactionListener* listener : listeners) {
589 if (NS_WARN_IF(!listener)) {
590 return NS_ERROR_FAILURE;
591 }
592 nsresult rv = listener->DidBeginBatch(this, aResult);
593 if (NS_FAILED(rv)) {
594 NS_WARNING("nsITransactionListener::DidBeginBatch() failed");
595 return rv;
596 }
597 }
598 return NS_OK;
599 }
600
WillEndBatchNotify(bool * aInterrupt)601 nsresult TransactionManager::WillEndBatchNotify(bool* aInterrupt) {
602 nsCOMArray<nsITransactionListener> listeners(mListeners);
603 for (nsITransactionListener* listener : listeners) {
604 if (NS_WARN_IF(!listener)) {
605 return NS_ERROR_FAILURE;
606 }
607 nsresult rv = listener->WillEndBatch(this, aInterrupt);
608 if (NS_FAILED(rv)) {
609 NS_WARNING("nsITransactionListener::WillEndBatch() failed");
610 return rv;
611 }
612 if (*aInterrupt) {
613 return NS_OK;
614 }
615 }
616 return NS_OK;
617 }
618
DidEndBatchNotify(nsresult aResult)619 nsresult TransactionManager::DidEndBatchNotify(nsresult aResult) {
620 nsCOMArray<nsITransactionListener> listeners(mListeners);
621 for (nsITransactionListener* listener : listeners) {
622 if (NS_WARN_IF(!listener)) {
623 return NS_ERROR_FAILURE;
624 }
625 nsresult rv = listener->DidEndBatch(this, aResult);
626 if (NS_FAILED(rv)) {
627 NS_WARNING("nsITransactionListener::DidEndBatch() failed");
628 return rv;
629 }
630 }
631 return NS_OK;
632 }
633
WillMergeNotify(nsITransaction * aTop,nsITransaction * aTransaction,bool * aInterrupt)634 nsresult TransactionManager::WillMergeNotify(nsITransaction* aTop,
635 nsITransaction* aTransaction,
636 bool* aInterrupt) {
637 nsCOMArray<nsITransactionListener> listeners(mListeners);
638 for (nsITransactionListener* listener : listeners) {
639 if (NS_WARN_IF(!listener)) {
640 return NS_ERROR_FAILURE;
641 }
642 nsresult rv = listener->WillMerge(this, aTop, aTransaction, aInterrupt);
643 if (NS_FAILED(rv)) {
644 NS_WARNING("nsITransactionListener::WillMerge() failed");
645 return rv;
646 }
647 if (*aInterrupt) {
648 return NS_OK;
649 }
650 }
651 return NS_OK;
652 }
653
DidMergeNotify(nsITransaction * aTop,nsITransaction * aTransaction,bool aDidMerge,nsresult aMergeResult)654 nsresult TransactionManager::DidMergeNotify(nsITransaction* aTop,
655 nsITransaction* aTransaction,
656 bool aDidMerge,
657 nsresult aMergeResult) {
658 nsCOMArray<nsITransactionListener> listeners(mListeners);
659 for (nsITransactionListener* listener : listeners) {
660 if (NS_WARN_IF(!listener)) {
661 return NS_ERROR_FAILURE;
662 }
663 nsresult rv =
664 listener->DidMerge(this, aTop, aTransaction, aDidMerge, aMergeResult);
665 if (NS_FAILED(rv)) {
666 NS_WARNING("nsITransactionListener::DidMerge() failed");
667 return rv;
668 }
669 }
670 return NS_OK;
671 }
672
BeginTransaction(nsITransaction * aTransaction,nsISupports * aData)673 nsresult TransactionManager::BeginTransaction(nsITransaction* aTransaction,
674 nsISupports* aData) {
675 // XXX: POSSIBLE OPTIMIZATION
676 // We could use a factory that pre-allocates/recycles transaction items.
677 RefPtr<TransactionItem> transactionItem = new TransactionItem(aTransaction);
678
679 if (aData) {
680 nsCOMArray<nsISupports>& data = transactionItem->GetData();
681 data.AppendObject(aData);
682 }
683
684 mDoStack.Push(transactionItem);
685
686 nsresult rv = transactionItem->DoTransaction();
687 if (NS_FAILED(rv)) {
688 NS_WARNING("TransactionItem::DoTransaction() failed");
689 transactionItem = mDoStack.Pop();
690 }
691 return rv;
692 }
693
EndTransaction(bool aAllowEmpty)694 nsresult TransactionManager::EndTransaction(bool aAllowEmpty) {
695 RefPtr<TransactionItem> transactionItem = mDoStack.Pop();
696 if (NS_WARN_IF(!transactionItem)) {
697 return NS_ERROR_FAILURE;
698 }
699
700 nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
701 if (!transaction && !aAllowEmpty) {
702 // If we get here, the transaction must be a dummy batch transaction
703 // created by BeginBatch(). If it contains no children, get rid of it!
704 if (!transactionItem->NumberOfChildren()) {
705 return NS_OK;
706 }
707 }
708
709 // Check if the transaction is transient. If it is, there's nothing
710 // more to do, just return.
711 if (transaction) {
712 bool isTransient = false;
713 nsresult rv = transaction->GetIsTransient(&isTransient);
714 if (NS_FAILED(rv)) {
715 NS_WARNING("nsITransaction::GetIsTransient() failed");
716 return rv;
717 }
718 // XXX: Should we be clearing the redo stack if the transaction
719 // is transient and there is nothing on the do stack?
720 if (isTransient) {
721 return NS_OK;
722 }
723 }
724
725 if (!mMaxTransactionCount) {
726 return NS_OK;
727 }
728
729 // Check if there is a transaction on the do stack. If there is,
730 // the current transaction is a "sub" transaction, and should
731 // be added to the transaction at the top of the do stack.
732 RefPtr<TransactionItem> topTransactionItem = mDoStack.Peek();
733 if (topTransactionItem) {
734 // XXX: What do we do if this fails?
735 nsresult rv = topTransactionItem->AddChild(*transactionItem);
736 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
737 "TransactionItem::AddChild() failed");
738 return rv;
739 }
740
741 // The transaction succeeded, so clear the redo stack.
742 mRedoStack.Clear();
743
744 // Check if we can coalesce this transaction with the one at the top
745 // of the undo stack.
746 topTransactionItem = mUndoStack.Peek();
747 if (transaction && topTransactionItem) {
748 bool didMerge = false;
749 nsCOMPtr<nsITransaction> topTransaction =
750 topTransactionItem->GetTransaction();
751 if (topTransaction) {
752 bool doInterrupt = false;
753 nsresult rv = WillMergeNotify(topTransaction, transaction, &doInterrupt);
754 if (NS_FAILED(rv)) {
755 NS_WARNING("TransactionManager::WillMergeNotify() failed");
756 return rv;
757 }
758
759 if (!doInterrupt) {
760 nsresult rv = topTransaction->Merge(transaction, &didMerge);
761 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
762 "nsITransaction::Merge() failed");
763 nsresult rv2 =
764 DidMergeNotify(topTransaction, transaction, didMerge, rv);
765 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2),
766 "TransactionManager::DidMergeNotify() failed");
767 if (didMerge) {
768 return NS_SUCCEEDED(rv) ? rv2 : rv;
769 }
770 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
771 "The previous error was ignored");
772 }
773 }
774 }
775
776 // Check to see if we've hit the max level of undo. If so,
777 // pop the bottom transaction off the undo stack and release it!
778 int32_t sz = mUndoStack.GetSize();
779 if (mMaxTransactionCount > 0 && sz >= mMaxTransactionCount) {
780 RefPtr<TransactionItem> overflow = mUndoStack.PopBottom();
781 }
782
783 // Push the transaction on the undo stack:
784 mUndoStack.Push(transactionItem.forget());
785 return NS_OK;
786 }
787
788 } // namespace mozilla
789