Bug 1447924 - part 4: Optimize NumbeOfUndoItems(), NumbeOfRedoItems(), CanUndo() and CanRedo() of EditorBase r=m_kato

Now, both TransactionManager.h and TransactionStack.h are exposed.  So,
TransactionManager::GetNumberOfUndoItems() and
TransactionManager::GetNumberOfRedoItems() can be rewritten with non-virtual
inline methods because they just return mUndoStack.GetSize() and
mRedoStack.GetSize().  Then, we can implement EditorBase::NumbeOfUndoItems(),
EditorBase::NumberOfRedoItems(), EditorBase::CanUndo() and
EditorBase::CanRedo() as inline methods.

MozReview-Commit-ID: 3CJd0VrlvFY

--HG--
extra : rebase_source : 6848d80a395f1c161e10bfb50d15bd63de288095

dom/html/nsTextEditorState.cpp

@@ -172,10 +172,7 @@ public:
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
     MOZ_ASSERT(mTextEditor);
 
-    bool canUndo;
-    DebugOnly<nsresult> rv = mTextEditor->CanUndo(&mPreviousEnabled, &canUndo);
-    MOZ_ASSERT(NS_SUCCEEDED(rv));
-
+    mPreviousEnabled = mTextEditor->IsUndoRedoEnabled();
     mTextEditor->EnableUndo(false);
   }
 
@@ -987,8 +984,8 @@ TextInputListener::OnEditActionHandled()
   RefPtr<TextEditor> textEditor = frame->GetTextEditor();
 
   // Get the number of undo / redo items
-  int32_t numUndoItems = textEditor->NumberOfUndoItems();
-  int32_t numRedoItems = textEditor->NumberOfRedoItems();
+  size_t numUndoItems = textEditor->NumberOfUndoItems();
+  size_t numRedoItems = textEditor->NumberOfRedoItems();
   if ((numUndoItems && !mHadUndoItems) || (!numUndoItems && mHadUndoItems) ||
       (numRedoItems && !mHadRedoItems) || (!numRedoItems && mHadRedoItems)) {
     // Modify the menu if undo or redo items are different

editor/composer/ComposerCommandsUpdater.cpp

@@ -7,6 +7,7 @@
 #include "mozilla/ComposerCommandsUpdater.h"
 
 #include "mozilla/mozalloc.h"           // for operator new
+#include "mozilla/TransactionManager.h" // for TransactionManager
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsComponentManagerUtils.h"    // for do_CreateInstance
@@ -116,8 +117,7 @@ ComposerCommandsUpdater::DidDo(nsITransactionManager* aManager,
                                nsresult aDoResult)
 {
   // only need to update if the status of the Undo menu item changes.
-  int32_t undoCount;
-  aManager->GetNumberOfUndoItems(&undoCount);
+  size_t undoCount = aManager->AsTransactionManager()->NumberOfUndoItems();
   if (undoCount == 1) {
     if (mFirstDoOfFirstUndo) {
       UpdateCommandGroup(NS_LITERAL_STRING("undo"));
@@ -142,11 +142,10 @@ ComposerCommandsUpdater::DidUndo(nsITransactionManager* aManager,
                                  nsITransaction* aTransaction,
                                  nsresult aUndoResult)
 {
-  int32_t undoCount;
-  aManager->GetNumberOfUndoItems(&undoCount);
-  if (undoCount == 0)
+  size_t undoCount = aManager->AsTransactionManager()->NumberOfUndoItems();
+  if (!undoCount) {
     mFirstDoOfFirstUndo = true;    // reset the state for the next do
-
+  }
   UpdateCommandGroup(NS_LITERAL_STRING("undo"));
   return NS_OK;
 }

editor/libeditor/EditorBase.cpp

@@ -828,43 +828,17 @@ EditorBase::EnableUndo(bool aEnable)
 NS_IMETHODIMP
 EditorBase::GetNumberOfUndoItems(int32_t* aNumItems)
 {
-  *aNumItems = NumberOfUndoItems();
-  return *aNumItems >= 0 ? NS_OK : NS_ERROR_FAILURE;
-}
-
-int32_t
-EditorBase::NumberOfUndoItems() const
-{
-  if (!mTransactionManager) {
-    return 0;
-  }
-  int32_t numItems = 0;
-  nsresult rv = mTransactionManager->GetNumberOfUndoItems(&numItems);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return -1;
-  }
-  return numItems;
+  *aNumItems = static_cast<int32_t>(NumberOfUndoItems());
+  MOZ_ASSERT(*aNumItems >= 0);
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::GetNumberOfRedoItems(int32_t* aNumItems)
 {
-  *aNumItems = NumberOfRedoItems();
-  return *aNumItems >= 0 ? NS_OK : NS_ERROR_FAILURE;
-}
-
-int32_t
-EditorBase::NumberOfRedoItems() const
-{
-  if (!mTransactionManager) {
-    return 0;
-  }
-  int32_t numItems = 0;
-  nsresult rv = mTransactionManager->GetNumberOfRedoItems(&numItems);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return -1;
-  }
-  return numItems;
+  *aNumItems = static_cast<int32_t>(NumberOfRedoItems());
+  MOZ_ASSERT(*aNumItems >= 0);
+  return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -894,9 +868,9 @@ EditorBase::Undo(uint32_t aCount)
 {
   ForceCompositionEnd();
 
-  bool hasTransactionManager, hasTransaction = false;
-  CanUndo(&hasTransactionManager, &hasTransaction);
-  NS_ENSURE_TRUE(hasTransaction, NS_OK);
+  if (!CanUndo()) {
+    return NS_OK;
+  }
 
   AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
 
@@ -919,24 +893,20 @@ NS_IMETHODIMP
 EditorBase::CanUndo(bool* aIsEnabled,
                     bool* aCanUndo)
 {
-  NS_ENSURE_TRUE(aIsEnabled && aCanUndo, NS_ERROR_NULL_POINTER);
-  *aIsEnabled = !!mTransactionManager;
-  if (*aIsEnabled) {
-    int32_t numTxns = 0;
-    mTransactionManager->GetNumberOfUndoItems(&numTxns);
-    *aCanUndo = !!numTxns;
-  } else {
-    *aCanUndo = false;
+  if (NS_WARN_IF(!aIsEnabled) || NS_WARN_IF(!aCanUndo)) {
+    return NS_ERROR_INVALID_ARG;
   }
+  *aCanUndo = CanUndo();
+  *aIsEnabled = IsUndoRedoEnabled();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::Redo(uint32_t aCount)
 {
-  bool hasTransactionManager, hasTransaction = false;
-  CanRedo(&hasTransactionManager, &hasTransaction);
-  NS_ENSURE_TRUE(hasTransaction, NS_OK);
+  if (!CanRedo()) {
+    return NS_OK;
+  }
 
   AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
 
@@ -958,16 +928,11 @@ EditorBase::Redo(uint32_t aCount)
 NS_IMETHODIMP
 EditorBase::CanRedo(bool* aIsEnabled, bool* aCanRedo)
 {
-  NS_ENSURE_TRUE(aIsEnabled && aCanRedo, NS_ERROR_NULL_POINTER);
-
-  *aIsEnabled = !!mTransactionManager;
-  if (*aIsEnabled) {
-    int32_t numTxns = 0;
-    mTransactionManager->GetNumberOfRedoItems(&numTxns);
-    *aCanRedo = !!numTxns;
-  } else {
-    *aCanRedo = false;
+  if (NS_WARN_IF(!aIsEnabled) || NS_WARN_IF(!aCanRedo)) {
+    return NS_ERROR_INVALID_ARG;
   }
+  *aCanRedo = CanRedo();
+  *aIsEnabled = IsUndoRedoEnabled();
   return NS_OK;
 }
 

editor/libeditor/EditorBase.h

@@ -15,6 +15,7 @@
 #include "mozilla/SelectionState.h"     // for RangeUpdater, etc.
 #include "mozilla/StyleSheet.h"         // for StyleSheet
 #include "mozilla/TextEditRules.h"      // for TextEditRules
+#include "mozilla/TransactionManager.h" // for TransactionManager
 #include "mozilla/WeakPtr.h"            // for WeakPtr
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Text.h"
@@ -79,7 +80,6 @@ class TextComposition;
 class TextEditor;
 class TextInputListener;
 class TextServicesDocument;
-class TransactionManager;
 enum class EditAction : int32_t;
 
 namespace dom {
@@ -1100,11 +1100,36 @@ public:
   bool ShouldHandleIMEComposition() const;
 
   /**
-   * Returns number of undo or redo items.  If TransactionManager returns
-   * unexpected error, returns -1.
+   * Returns number of undo or redo items.
    */
-  int32_t NumberOfUndoItems() const;
-  int32_t NumberOfRedoItems() const;
+  size_t NumberOfUndoItems() const
+  {
+    return mTransactionManager ? mTransactionManager->NumberOfUndoItems() : 0;
+  }
+  size_t NumberOfRedoItems() const
+  {
+    return mTransactionManager ? mTransactionManager->NumberOfRedoItems() : 0;
+  }
+
+  /**
+   * Returns true if this editor can store transactions for undo/redo.
+   */
+  bool IsUndoRedoEnabled() const
+  {
+    return !!mTransactionManager;
+  }
+
+  /**
+   * Return true if it's possible to undo/redo right now.
+   */
+  bool CanUndo() const
+  {
+    return IsUndoRedoEnabled() && NumberOfUndoItems() > 0;
+  }
+  bool CanRedo() const
+  {
+    return IsUndoRedoEnabled() && NumberOfRedoItems() > 0;
+  }
 
   /**
    * From html rules code - migration in progress.

editor/libeditor/EditorCommands.cpp

@@ -68,8 +68,8 @@ UndoCommand::IsCommandEnabled(const char* aCommandName,
   if (!textEditor->IsSelectionEditable()) {
     return NS_OK;
   }
-  bool isEnabled = false;
-  return editor->CanUndo(&isEnabled, aIsEnabled);
+  *aIsEnabled = textEditor->CanUndo();
+  return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -127,8 +127,8 @@ RedoCommand::IsCommandEnabled(const char* aCommandName,
   if (!textEditor->IsSelectionEditable()) {
     return NS_OK;
   }
-  bool isEnabled = false;
-  return editor->CanRedo(&isEnabled, aIsEnabled);
+  *aIsEnabled = textEditor->CanRedo();
+  return NS_OK;
 }
 
 NS_IMETHODIMP

editor/txmgr/TransactionManager.cpp

@@ -257,14 +257,16 @@ TransactionManager::EndBatch(bool aAllowEmpty)
 NS_IMETHODIMP
 TransactionManager::GetNumberOfUndoItems(int32_t* aNumItems)
 {
-  *aNumItems = mUndoStack.GetSize();
+  *aNumItems = static_cast<int32_t>(NumberOfUndoItems());
+  MOZ_ASSERT(*aNumItems >= 0);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TransactionManager::GetNumberOfRedoItems(int32_t* aNumItems)
 {
-  *aNumItems = mRedoStack.GetSize();
+  *aNumItems = static_cast<int32_t>(NumberOfRedoItems());
+  MOZ_ASSERT(*aNumItems >= 0);
   return NS_OK;
 }
 

editor/txmgr/TransactionManager.h

@@ -36,6 +36,15 @@ public:
   already_AddRefed<nsITransaction> PeekUndoStack();
   already_AddRefed<nsITransaction> PeekRedoStack();
 
+  size_t NumberOfUndoItems() const
+  {
+    return mUndoStack.GetSize();
+  }
+  size_t NumberOfRedoItems() const
+  {
+    return mRedoStack.GetSize();
+  }
+
   nsresult WillDoNotify(nsITransaction* aTransaction, bool* aInterrupt);
   nsresult DidDoNotify(nsITransaction* aTransaction, nsresult aExecuteResult);
   nsresult WillUndoNotify(nsITransaction* aTransaction, bool* aInterrupt);
@@ -70,4 +79,10 @@ private:
 
 } // namespace mozilla
 
+mozilla::TransactionManager*
+nsITransactionManager::AsTransactionManager()
+{
+  return static_cast<mozilla::TransactionManager*>(this);
+}
+
 #endif // #ifndef mozilla_TransactionManager_h

editor/txmgr/nsITransactionManager.idl

@@ -7,6 +7,12 @@
 #include "nsITransaction.idl"
 #include "nsITransactionListener.idl"
 
+%{C++
+namespace mozilla {
+class TransactionManager;
+} // namespace mozilla
+%}
+
 /**
  * The nsITransactionManager interface.
  * <P>
@@ -143,6 +149,16 @@ interface nsITransactionManager : nsISupports
    * @param aListener the lister to remove.
    */
   void RemoveListener(in nsITransactionListener aListener);
+
+%{C++
+  /**
+   * AsTransactionManager() returns a pointer to TransactionManager class.
+   *
+   * In order to avoid circular dependency issues, this method is defined
+   * in mozilla/TransactionManager.h.  Consumers need to #include that header.
+   */
+  inline mozilla::TransactionManager* AsTransactionManager();
+%}
 };
 
 %{ C++