Bug 1284422 part.11 Remove "IMS: " and "IMEStateManager::" from log of IMEStateManager.cpp r=m_kato
authorMasayuki Nakano <masayuki@d-toybox.com>
Tue, 05 Jul 2016 19:05:23 +0900
changeset 384763 70852530cdb504d57cadcee62aed14511ac97f3d
parent 384762 b12eb7caa71239b687be62fd196fe7b3ddeb2b94
child 384764 f3d52541b5032d74bf353f1bc8529f29b8cc1ed4
push id22359
push userbmo:rchien@mozilla.com
push dateThu, 07 Jul 2016 03:18:15 +0000
reviewersm_kato
bugs1284422
milestone50.0a1
Bug 1284422 part.11 Remove "IMS: " and "IMEStateManager::" from log of IMEStateManager.cpp r=m_kato MozReview-Commit-ID: K5PwEiHTJQX
dom/events/IMEStateManager.cpp
--- a/dom/events/IMEStateManager.cpp
+++ b/dom/events/IMEStateManager.cpp
@@ -42,25 +42,25 @@ namespace mozilla {
 
 using namespace dom;
 using namespace widget;
 
 /**
  * When a method is called, log its arguments and/or related static variables
  * with LogLevel::Info.  However, if it puts too many logs like
  * OnDestroyPresContext(), should long only when the method actually does
- * something. In this case, the log should start with "ISM: <method name>".
+ * something. In this case, the log should start with "<method name>".
  *
  * When a method quits due to unexpected situation, log the reason with
  * LogLevel::Error.  In this case, the log should start with
- * "ISM:   <method name>(), FAILED".  The indent makes the log look easier.
+ * "<method name>(), FAILED".  The indent makes the log look easier.
  *
  * When a method does something only in some situations and it may be important
  * for debug, log the information with LogLevel::Debug.  In this case, the log
- * should start with "ISM:   <method name>(),".
+ * should start with "  <method name>(),".
  */
 LazyLogModule sISMLog("IMEStateManager");
 
 static const char*
 GetBoolName(bool aBool)
 {
   return aBool ? "true" : "false";
 }
@@ -157,34 +157,33 @@ IMEStateManager::Init()
     false);
 }
 
 // static
 void
 IMEStateManager::Shutdown()
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::Shutdown(), "
-     "sTextCompositions=0x%p, sTextCompositions->Length()=%u",
+    ("Shutdown(), sTextCompositions=0x%p, sTextCompositions->Length()=%u",
      sTextCompositions, sTextCompositions ? sTextCompositions->Length() : 0));
 
   MOZ_ASSERT(!sTextCompositions || !sTextCompositions->Length());
   delete sTextCompositions;
   sTextCompositions = nullptr;
 }
 
 // static
 void
 IMEStateManager::OnTabParentDestroying(TabParent* aTabParent)
 {
   if (sActiveTabParent != aTabParent) {
     return;
   }
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnTabParentDestroying(aTabParent=0x%p), "
+    ("OnTabParentDestroying(aTabParent=0x%p), "
      "The active TabParent is being destroyed", aTabParent));
 
   // The active remote process might have crashed.
   sActiveTabParent = nullptr;
 
   // TODO: Need to cancel composition without TextComposition and make
   //       disable IME.
 }
@@ -201,17 +200,17 @@ IMEStateManager::WidgetDestroyed(nsIWidg
   }
 }
 
 // static
 void
 IMEStateManager::StopIMEStateManagement()
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::StopIMEStateManagement()"));
+    ("StopIMEStateManagement()"));
 
   // NOTE: Don't set input context from here since this has already lost
   //       the rights to change input context.
 
   if (sTextCompositions && sPresContext) {
     NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, sPresContext);
   }
   sActiveInputContextWidget = nullptr;
@@ -223,75 +222,73 @@ IMEStateManager::StopIMEStateManagement(
 
 // static
 void
 IMEStateManager::MaybeStartOffsetUpdatedInChild(nsIWidget* aWidget,
                                                 uint32_t aStartOffset)
 {
   if (NS_WARN_IF(!sTextCompositions)) {
     MOZ_LOG(sISMLog, LogLevel::Warning,
-      ("ISM: IMEStateManager::MaybeStartOffsetUpdatedInChild("
-       "aWidget=0x%p, aStartOffset=%u), called when there is no "
-       "composition", aWidget, aStartOffset));
+      ("MaybeStartOffsetUpdatedInChild(aWidget=0x%p, aStartOffset=%u), "
+       "called when there is no composition", aWidget, aStartOffset));
     return;
   }
 
   RefPtr<TextComposition> composition = GetTextCompositionFor(aWidget);
   if (NS_WARN_IF(!composition)) {
     MOZ_LOG(sISMLog, LogLevel::Warning,
-      ("ISM: IMEStateManager::MaybeStartOffsetUpdatedInChild("
-       "aWidget=0x%p, aStartOffset=%u), called when there is no "
-       "composition", aWidget, aStartOffset));
+      ("MaybeStartOffsetUpdatedInChild(aWidget=0x%p, aStartOffset=%u), "
+       "called when there is no composition", aWidget, aStartOffset));
     return;
   }
 
   if (composition->NativeOffsetOfStartComposition() == aStartOffset) {
     return;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::MaybeStartOffsetUpdatedInChild("
-     "aWidget=0x%p, aStartOffset=%u), old offset=%u",
+    ("MaybeStartOffsetUpdatedInChild(aWidget=0x%p, aStartOffset=%u), "
+     "old offset=%u",
      aWidget, aStartOffset, composition->NativeOffsetOfStartComposition()));
   composition->OnStartOffsetUpdatedInChild(aStartOffset);
 }
 
 // static
 nsresult
 IMEStateManager::OnDestroyPresContext(nsPresContext* aPresContext)
 {
   NS_ENSURE_ARG_POINTER(aPresContext);
 
   // First, if there is a composition in the aPresContext, clean up it.
   if (sTextCompositions) {
     TextCompositionArray::index_type i =
       sTextCompositions->IndexOf(aPresContext);
     if (i != TextCompositionArray::NoIndex) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::OnDestroyPresContext(), "
+        ("  OnDestroyPresContext(), "
          "removing TextComposition instance from the array (index=%u)", i));
       // there should be only one composition per presContext object.
       sTextCompositions->ElementAt(i)->Destroy();
       sTextCompositions->RemoveElementAt(i);
       if (sTextCompositions->IndexOf(aPresContext) !=
             TextCompositionArray::NoIndex) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::OnDestroyPresContext(), FAILED to remove "
+          ("  OnDestroyPresContext(), FAILED to remove "
            "TextComposition instance from the array"));
         MOZ_CRASH("Failed to remove TextComposition instance from the array");
       }
     }
   }
 
   if (aPresContext != sPresContext) {
     return NS_OK;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnDestroyPresContext(aPresContext=0x%p), "
+    ("OnDestroyPresContext(aPresContext=0x%p), "
      "sPresContext=0x%p, sContent=0x%p, sTextCompositions=0x%p",
      aPresContext, sPresContext, sContent.get(), sTextCompositions));
 
   DestroyIMEContentObserver();
 
   nsCOMPtr<nsIWidget> widget = sPresContext->GetRootWidget();
   if (widget) {
     IMEState newState = GetNewIMEState(sPresContext, nullptr);
@@ -314,17 +311,17 @@ IMEStateManager::OnRemoveContent(nsPresC
 
   // First, if there is a composition in the aContent, clean up it.
   if (sTextCompositions) {
     RefPtr<TextComposition> compositionInContent =
       sTextCompositions->GetCompositionInContent(aPresContext, aContent);
 
     if (compositionInContent) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::OnRemoveContent(), "
+        ("  OnRemoveContent(), "
          "composition is in the content"));
 
       // Try resetting the native IME state.  Be aware, typically, this method
       // is called during the content being removed.  Then, the native
       // composition events which are caused by following APIs are ignored due
       // to unsafe to run script (in PresShell::HandleEvent()).
       nsCOMPtr<nsIWidget> widget = aPresContext->GetRootWidget();
       MOZ_ASSERT(widget, "Why is there no widget?");
@@ -337,18 +334,18 @@ IMEStateManager::OnRemoveContent(nsPresC
   }
 
   if (!sPresContext || !sContent ||
       !nsContentUtils::ContentIsDescendantOf(sContent, aContent)) {
     return NS_OK;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnRemoveContent(aPresContext=0x%p, "
-     "aContent=0x%p), sPresContext=0x%p, sContent=0x%p, sTextCompositions=0x%p",
+    ("OnRemoveContent(aPresContext=0x%p, aContent=0x%p), "
+     "sPresContext=0x%p, sContent=0x%p, sTextCompositions=0x%p",
      aPresContext, aContent, sPresContext, sContent.get(), sTextCompositions));
 
   DestroyIMEContentObserver();
 
   // Current IME transaction should commit
   nsCOMPtr<nsIWidget> widget = sPresContext->GetRootWidget();
   if (widget) {
     IMEState newState = GetNewIMEState(sPresContext, nullptr);
@@ -366,34 +363,33 @@ IMEStateManager::OnRemoveContent(nsPresC
 
 // static
 nsresult
 IMEStateManager::OnChangeFocus(nsPresContext* aPresContext,
                                nsIContent* aContent,
                                InputContextAction::Cause aCause)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnChangeFocus(aPresContext=0x%p, "
-     "aContent=0x%p, aCause=%s)",
+    ("OnChangeFocus(aPresContext=0x%p, aContent=0x%p, aCause=%s)",
      aPresContext, aContent, GetActionCauseName(aCause)));
 
   InputContextAction action(aCause);
   return OnChangeFocusInternal(aPresContext, aContent, action);
 }
 
 // static
 nsresult
 IMEStateManager::OnChangeFocusInternal(nsPresContext* aPresContext,
                                        nsIContent* aContent,
                                        InputContextAction aAction)
 {
   RefPtr<TabParent> newTabParent = TabParent::GetFrom(aContent);
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnChangeFocusInternal(aPresContext=0x%p, "
+    ("OnChangeFocusInternal(aPresContext=0x%p, "
      "aContent=0x%p (TabParent=0x%p), aAction={ mCause=%s, mFocusChange=%s }), "
      "sPresContext=0x%p, sContent=0x%p, sActiveTabParent=0x%p, "
      "sActiveIMEContentObserver=0x%p, sInstalledMenuKeyboardListener=%s",
      aPresContext, aContent, newTabParent.get(),
      GetActionCauseName(aAction.mCause),
      GetActionFocusChangeName(aAction.mFocusChange),
      sPresContext, sContent.get(), sActiveTabParent.get(),
      sActiveIMEContentObserver.get(),
@@ -416,39 +412,39 @@ IMEStateManager::OnChangeFocusInternal(n
   if (sActiveIMEContentObserver &&
       (aPresContext || !sActiveIMEContentObserver->KeepAliveDuringDeactive()) &&
       !sActiveIMEContentObserver->IsManaging(aPresContext, aContent)) {
     DestroyIMEContentObserver();
   }
 
   if (!aPresContext) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnChangeFocusInternal(), "
+      ("  OnChangeFocusInternal(), "
        "no nsPresContext is being activated"));
     return NS_OK;
   }
 
   nsIContentParent* currentContentParent =
     sActiveTabParent ? sActiveTabParent->Manager() : nullptr;
   nsIContentParent* newContentParent =
     newTabParent ? newTabParent->Manager() : nullptr;
   if (sActiveTabParent && currentContentParent != newContentParent) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnChangeFocusInternal(), notifying previous "
+      ("  OnChangeFocusInternal(), notifying previous "
        "focused child process of parent process or another child process "
        "getting focus"));
     Unused << sActiveTabParent->SendStopIMEStateManagement();
   }
 
   nsCOMPtr<nsIWidget> widget =
     (sPresContext == aPresContext) ? oldWidget.get() :
                                      aPresContext->GetRootWidget();
   if (NS_WARN_IF(!widget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::OnChangeFocusInternal(), FAILED due to "
+      ("  OnChangeFocusInternal(), FAILED due to "
        "no widget to manage its IME state"));
     return NS_OK;
   }
 
   // If a child process has focus, we should disable IME state until the child
   // process actually gets focus because if user types keys before that they
   // are handled by IME.
   IMEState newState =
@@ -466,46 +462,46 @@ IMEStateManager::OnChangeFocusInternal(n
       Unused << newTabParent->
         SendMenuKeyboardListenerInstalled(sInstalledMenuKeyboardListener);
       setIMEState = sInstalledMenuKeyboardListener;
     } else if (focusActuallyChanging) {
       InputContext context = widget->GetInputContext();
       if (context.mIMEState.mEnabled == IMEState::DISABLED) {
         setIMEState = false;
         MOZ_LOG(sISMLog, LogLevel::Debug,
-          ("ISM:   IMEStateManager::OnChangeFocusInternal(), doesn't set IME "
+          ("  OnChangeFocusInternal(), doesn't set IME "
            "state because focused element (or document) is in a child process "
            "and the IME state is already disabled"));
       } else {
         MOZ_LOG(sISMLog, LogLevel::Debug,
-          ("ISM:   IMEStateManager::OnChangeFocusInternal(), will disable IME "
+          ("  OnChangeFocusInternal(), will disable IME "
            "until new focused element (or document) in the child process "
            "will get focus actually"));
       }
     } else {
       // When focus is NOT changed actually, we shouldn't set IME state since
       // that means that the window is being activated and the child process
       // may have composition.  Then, we shouldn't commit the composition with
       // making IME state disabled.
       setIMEState = false; 
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::OnChangeFocusInternal(), doesn't set IME "
+        ("  OnChangeFocusInternal(), doesn't set IME "
          "state because focused element (or document) is already in the child "
          "process"));
     }
   }
 
   if (setIMEState) {
     if (!focusActuallyChanging) {
       // actual focus isn't changing, but if IME enabled state is changing,
       // we should do it.
       InputContext context = widget->GetInputContext();
       if (context.mIMEState.mEnabled == newState.mEnabled) {
         MOZ_LOG(sISMLog, LogLevel::Debug,
-          ("ISM:   IMEStateManager::OnChangeFocusInternal(), "
+          ("  OnChangeFocusInternal(), "
            "neither focus nor IME state is changing"));
         return NS_OK;
       }
       aAction.mFocusChange = InputContextAction::FOCUS_NOT_CHANGED;
 
       // Even if focus isn't changing actually, we should commit current
       // composition here since the IME state is changing.
       if (sPresContext && oldWidget && !focusActuallyChanging) {
@@ -530,32 +526,32 @@ IMEStateManager::OnChangeFocusInternal(n
 
   // Don't call CreateIMEContentObserver() here except when a plugin gets
   // focus because it will be called from the focus event handler of focused
   // editor.
   if (newState.mEnabled == IMEState::PLUGIN) {
     CreateIMEContentObserver(nullptr);
     if (sActiveIMEContentObserver) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::OnChangeFocusInternal(), an "
+        ("  OnChangeFocusInternal(), an "
          "IMEContentObserver instance is created for plugin and trying to "
          "flush its pending notifications..."));
       sActiveIMEContentObserver->TryToFlushPendingNotifications();
     }
   }
 
   return NS_OK;
 }
 
 // static
 void
 IMEStateManager::OnInstalledMenuKeyboardListener(bool aInstalling)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnInstalledMenuKeyboardListener(aInstalling=%s), "
+    ("OnInstalledMenuKeyboardListener(aInstalling=%s), "
      "sInstalledMenuKeyboardListener=%s",
      GetBoolName(aInstalling), GetBoolName(sInstalledMenuKeyboardListener)));
 
   sInstalledMenuKeyboardListener = aInstalling;
 
   InputContextAction action(InputContextAction::CAUSE_UNKNOWN,
     aInstalling ? InputContextAction::MENU_GOT_PSEUDO_FOCUS :
                   InputContextAction::MENU_LOST_PSEUDO_FOCUS);
@@ -564,113 +560,113 @@ IMEStateManager::OnInstalledMenuKeyboard
 
 // static
 bool
 IMEStateManager::OnMouseButtonEventInEditor(nsPresContext* aPresContext,
                                             nsIContent* aContent,
                                             nsIDOMMouseEvent* aMouseEvent)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnMouseButtonEventInEditor(aPresContext=0x%p, "
+    ("OnMouseButtonEventInEditor(aPresContext=0x%p, "
      "aContent=0x%p, aMouseEvent=0x%p), sPresContext=0x%p, sContent=0x%p",
      aPresContext, aContent, aMouseEvent, sPresContext, sContent.get()));
 
   if (sPresContext != aPresContext || sContent != aContent) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnMouseButtonEventInEditor(), "
+      ("  OnMouseButtonEventInEditor(), "
        "the mouse event isn't fired on the editor managed by ISM"));
     return false;
   }
 
   if (!sActiveIMEContentObserver) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnMouseButtonEventInEditor(), "
+      ("  OnMouseButtonEventInEditor(), "
        "there is no active IMEContentObserver"));
     return false;
   }
 
   if (!sActiveIMEContentObserver->IsManaging(aPresContext, aContent)) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnMouseButtonEventInEditor(), "
+      ("  OnMouseButtonEventInEditor(), "
        "the active IMEContentObserver isn't managing the editor"));
     return false;
   }
 
   WidgetMouseEvent* internalEvent =
     aMouseEvent->AsEvent()->WidgetEventPtr()->AsMouseEvent();
   if (NS_WARN_IF(!internalEvent)) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnMouseButtonEventInEditor(), "
+      ("  OnMouseButtonEventInEditor(), "
        "the internal event of aMouseEvent isn't WidgetMouseEvent"));
     return false;
   }
 
   bool consumed =
     sActiveIMEContentObserver->OnMouseButtonEvent(aPresContext, internalEvent);
 
   if (MOZ_LOG_TEST(sISMLog, LogLevel::Info)) {
     nsAutoString eventType;
     aMouseEvent->AsEvent()->GetType(eventType);
     MOZ_LOG(sISMLog, LogLevel::Info,
-      ("ISM:   IMEStateManager::OnMouseButtonEventInEditor(), "
+      ("  OnMouseButtonEventInEditor(), "
        "mouse event (type=%s, button=%d) is %s",
        NS_ConvertUTF16toUTF8(eventType).get(), internalEvent->button,
        consumed ? "consumed" : "not consumed"));
   }
 
   return consumed;
 }
 
 // static
 void
 IMEStateManager::OnClickInEditor(nsPresContext* aPresContext,
                                  nsIContent* aContent,
                                  nsIDOMMouseEvent* aMouseEvent)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnClickInEditor(aPresContext=0x%p, aContent=0x%p, "
-     "aMouseEvent=0x%p), sPresContext=0x%p, sContent=0x%p",
+    ("OnClickInEditor(aPresContext=0x%p, aContent=0x%p, aMouseEvent=0x%p), "
+     "sPresContext=0x%p, sContent=0x%p",
      aPresContext, aContent, aMouseEvent, sPresContext, sContent.get()));
 
   if (sPresContext != aPresContext || sContent != aContent) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnClickInEditor(), "
+      ("  OnClickInEditor(), "
        "the mouse event isn't fired on the editor managed by ISM"));
     return;
   }
 
   nsCOMPtr<nsIWidget> widget = aPresContext->GetRootWidget();
   NS_ENSURE_TRUE_VOID(widget);
 
   bool isTrusted;
   nsresult rv = aMouseEvent->AsEvent()->GetIsTrusted(&isTrusted);
   NS_ENSURE_SUCCESS_VOID(rv);
   if (!isTrusted) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnClickInEditor(), "
+      ("  OnClickInEditor(), "
        "the mouse event isn't a trusted event"));
     return; // ignore untrusted event.
   }
 
   int16_t button;
   rv = aMouseEvent->GetButton(&button);
   NS_ENSURE_SUCCESS_VOID(rv);
   if (button != 0) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnClickInEditor(), "
+      ("  OnClickInEditor(), "
        "the mouse event isn't a left mouse button event"));
     return; // not a left click event.
   }
 
   int32_t clickCount;
   rv = aMouseEvent->GetDetail(&clickCount);
   NS_ENSURE_SUCCESS_VOID(rv);
   if (clickCount != 1) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnClickInEditor(), "
+      ("  OnClickInEditor(), "
        "the mouse event isn't a single click event"));
     return; // should notify only first click event.
   }
 
   uint16_t inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
   aMouseEvent->GetMozInputSource(&inputSource);
   InputContextAction::Cause cause =
     inputSource == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH ?
@@ -683,134 +679,133 @@ IMEStateManager::OnClickInEditor(nsPresC
 
 // static
 void
 IMEStateManager::OnFocusInEditor(nsPresContext* aPresContext,
                                  nsIContent* aContent,
                                  nsIEditor* aEditor)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnFocusInEditor(aPresContext=0x%p, aContent=0x%p, "
-     "aEditor=0x%p), sPresContext=0x%p, sContent=0x%p, "
-     "sActiveIMEContentObserver=0x%p",
+    ("OnFocusInEditor(aPresContext=0x%p, aContent=0x%p, aEditor=0x%p), "
+     "sPresContext=0x%p, sContent=0x%p, sActiveIMEContentObserver=0x%p",
      aPresContext, aContent, aEditor, sPresContext, sContent.get(),
      sActiveIMEContentObserver.get()));
 
   if (sPresContext != aPresContext || sContent != aContent) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnFocusInEditor(), "
+      ("  OnFocusInEditor(), "
        "an editor not managed by ISM gets focus"));
     return;
   }
 
   // If the IMEContentObserver instance isn't managing the editor actually,
   // we need to recreate the instance.
   if (sActiveIMEContentObserver) {
     if (sActiveIMEContentObserver->IsManaging(aPresContext, aContent)) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::OnFocusInEditor(), "
+        ("  OnFocusInEditor(), "
          "the editor is already being managed by sActiveIMEContentObserver"));
       return;
     }
     DestroyIMEContentObserver();
   }
 
   CreateIMEContentObserver(aEditor);
 
   // Let's flush the focus notification now.
   if (sActiveIMEContentObserver) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::OnFocusInEditor(), new IMEContentObserver is "
+      ("  OnFocusInEditor(), new IMEContentObserver is "
        "created, trying to flush pending notifications..."));
     sActiveIMEContentObserver->TryToFlushPendingNotifications();
   }
 }
 
 // static
 void
 IMEStateManager::OnEditorInitialized(nsIEditor* aEditor)
 {
   if (!sActiveIMEContentObserver ||
       sActiveIMEContentObserver->GetEditor() != aEditor) {
     return;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnEditorInitialized(aEditor=0x%p)",
+    ("OnEditorInitialized(aEditor=0x%p)",
      aEditor));
 
   sActiveIMEContentObserver->UnsuppressNotifyingIME();
 }
 
 // static
 void
 IMEStateManager::OnEditorDestroying(nsIEditor* aEditor)
 {
   if (!sActiveIMEContentObserver ||
       sActiveIMEContentObserver->GetEditor() != aEditor) {
     return;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnEditorDestroying(aEditor=0x%p)",
+    ("OnEditorDestroying(aEditor=0x%p)",
      aEditor));
 
   // The IMEContentObserver shouldn't notify IME of anything until reframing
   // is finished.
   sActiveIMEContentObserver->SuppressNotifyingIME();
 }
 
 // static
 void
 IMEStateManager::UpdateIMEState(const IMEState& aNewIMEState,
                                 nsIContent* aContent,
                                 nsIEditor* aEditor)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::UpdateIMEState(aNewIMEState={ mEnabled=%s, "
+    ("UpdateIMEState(aNewIMEState={ mEnabled=%s, "
      "mOpen=%s }, aContent=0x%p, aEditor=0x%p), "
      "sPresContext=0x%p, sContent=0x%p, sActiveIMEContentObserver=0x%p, "
      "sIsGettingNewIMEState=%s",
      GetIMEStateEnabledName(aNewIMEState.mEnabled),
      GetIMEStateSetOpenName(aNewIMEState.mOpen), aContent, aEditor,
      sPresContext, sContent.get(), sActiveIMEContentObserver.get(),
      GetBoolName(sIsGettingNewIMEState)));
 
   if (sIsGettingNewIMEState) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::UpdateIMEState(), "
+      ("  UpdateIMEState(), "
        "does nothing because of called while getting new IME state"));
     return;
   }
 
   if (NS_WARN_IF(!sPresContext)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::UpdateIMEState(), FAILED due to "
+      ("  UpdateIMEState(), FAILED due to "
        "no managing nsPresContext"));
     return;
   }
   nsCOMPtr<nsIWidget> widget = sPresContext->GetRootWidget();
   if (NS_WARN_IF(!widget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::UpdateIMEState(), FAILED due to "
+      ("  UpdateIMEState(), FAILED due to "
        "no widget for the managing nsPresContext"));
     return;
   }
 
   // Even if there is active IMEContentObserver, it may not be observing the
   // editor with current editable root content due to reframed.  In such case,
   // We should try to reinitialize the IMEContentObserver.
   if (sActiveIMEContentObserver && IsIMEObserverNeeded(aNewIMEState)) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::UpdateIMEState(), try to reinitialize the "
+      ("  UpdateIMEState(), try to reinitialize the "
        "active IMEContentObserver"));
     if (!sActiveIMEContentObserver->MaybeReinitialize(widget, sPresContext,
                                                       aContent, aEditor)) {
       MOZ_LOG(sISMLog, LogLevel::Error,
-        ("ISM:   IMEStateManager::UpdateIMEState(), failed to reinitialize the "
+        ("  UpdateIMEState(), failed to reinitialize the "
          "active IMEContentObserver"));
     }
   }
 
   // If there is no active IMEContentObserver or it isn't observing the
   // editor correctly, we should recreate it.
   bool createTextStateManager =
     (!sActiveIMEContentObserver ||
@@ -843,62 +838,62 @@ IMEStateManager::UpdateIMEState(const IM
 }
 
 // static
 IMEState
 IMEStateManager::GetNewIMEState(nsPresContext* aPresContext,
                                 nsIContent*    aContent)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::GetNewIMEState(aPresContext=0x%p, aContent=0x%p), "
+    ("GetNewIMEState(aPresContext=0x%p, aContent=0x%p), "
      "sInstalledMenuKeyboardListener=%s",
      aPresContext, aContent, GetBoolName(sInstalledMenuKeyboardListener)));
 
   // On Printing or Print Preview, we don't need IME.
   if (aPresContext->Type() == nsPresContext::eContext_PrintPreview ||
       aPresContext->Type() == nsPresContext::eContext_Print) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::GetNewIMEState() returns DISABLED because "
+      ("  GetNewIMEState() returns DISABLED because "
        "the nsPresContext is for print or print preview"));
     return IMEState(IMEState::DISABLED);
   }
 
   if (sInstalledMenuKeyboardListener) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::GetNewIMEState() returns DISABLED because "
+      ("  GetNewIMEState() returns DISABLED because "
        "menu keyboard listener was installed"));
     return IMEState(IMEState::DISABLED);
   }
 
   if (!aContent) {
     // Even if there are no focused content, the focused document might be
     // editable, such case is design mode.
     nsIDocument* doc = aPresContext->Document();
     if (doc && doc->HasFlag(NODE_IS_EDITABLE)) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::GetNewIMEState() returns ENABLED because "
+        ("  GetNewIMEState() returns ENABLED because "
          "design mode editor has focus"));
       return IMEState(IMEState::ENABLED);
     }
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::GetNewIMEState() returns DISABLED because "
+      ("  GetNewIMEState() returns DISABLED because "
        "no content has focus"));
     return IMEState(IMEState::DISABLED);
   }
 
   // nsIContent::GetDesiredIMEState() may cause a call of UpdateIMEState()
   // from nsEditor::PostCreate() because GetDesiredIMEState() needs to retrieve
   // an editor instance for the element if it's editable element.
   // For avoiding such nested IME state updates, we should set
   // sIsGettingNewIMEState here and UpdateIMEState() should check it.
   GettingNewIMEStateBlocker blocker;
 
   IMEState newIMEState = aContent->GetDesiredIMEState();
   MOZ_LOG(sISMLog, LogLevel::Debug,
-    ("ISM:   IMEStateManager::GetNewIMEState() returns { mEnabled=%s, "
+    ("  GetNewIMEState() returns { mEnabled=%s, "
      "mOpen=%s }",
      GetIMEStateEnabledName(newIMEState.mEnabled),
      GetIMEStateSetOpenName(newIMEState.mOpen)));
   return newIMEState;
 }
 
 static bool
 MayBeIMEUnawareWebApp(nsINode* aNode)
@@ -922,48 +917,48 @@ MayBeIMEUnawareWebApp(nsINode* aNode)
 // static
 void
 IMEStateManager::SetInputContextForChildProcess(
                    TabParent* aTabParent,
                    const InputContext& aInputContext,
                    const InputContextAction& aAction)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::SetInputContextForChildProcess(aTabParent=0x%p, "
+    ("SetInputContextForChildProcess(aTabParent=0x%p, "
      "aInputContext={ mIMEState={ mEnabled=%s, mOpen=%s }, "
      "mHTMLInputType=\"%s\", mHTMLInputInputmode=\"%s\", mActionHint=\"%s\" }, "
      "aAction={ mCause=%s, mAction=%s }, aTabParent=0x%p), sPresContext=0x%p, "
      "sActiveTabParent=0x%p",
      aTabParent, GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
      GetIMEStateSetOpenName(aInputContext.mIMEState.mOpen),
      NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputType).get(),
      NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputInputmode).get(),
      NS_ConvertUTF16toUTF8(aInputContext.mActionHint).get(),
      GetActionCauseName(aAction.mCause),
      GetActionFocusChangeName(aAction.mFocusChange),
      sPresContext, sActiveTabParent.get()));
 
   if (aTabParent != sActiveTabParent) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:    IMEStateManager::SetInputContextForChildProcess(), FAILED, "
+      ("  SetInputContextForChildProcess(), FAILED, "
        "because non-focused tab parent tries to set input context"));
     return;
   }
 
   if (NS_WARN_IF(!sPresContext)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:    IMEStateManager::SetInputContextForChildProcess(), FAILED, "
+      ("  SetInputContextForChildProcess(), FAILED, "
        "due to no focused presContext"));
     return;
   }
 
   nsCOMPtr<nsIWidget> widget = sPresContext->GetRootWidget();
   if (NS_WARN_IF(!widget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:    IMEStateManager::SetInputContextForChildProcess(), FAILED, "
+      ("  SetInputContextForChildProcess(), FAILED, "
        "due to no widget in the focused presContext"));
     return;
   }
 
   MOZ_ASSERT(aInputContext.mOrigin == InputContext::ORIGIN_CONTENT);
 
   SetInputContext(widget, aInputContext, aAction);
 }
@@ -971,17 +966,17 @@ IMEStateManager::SetInputContextForChild
 // static
 void
 IMEStateManager::SetIMEState(const IMEState& aState,
                              nsIContent* aContent,
                              nsIWidget* aWidget,
                              InputContextAction aAction)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::SetIMEState(aState={ mEnabled=%s, mOpen=%s }, "
+    ("SetIMEState(aState={ mEnabled=%s, mOpen=%s }, "
      "aContent=0x%p (TabParent=0x%p), aWidget=0x%p, aAction={ mCause=%s, "
      "mFocusChange=%s })",
      GetIMEStateEnabledName(aState.mEnabled),
      GetIMEStateSetOpenName(aState.mOpen), aContent,
      TabParent::GetFrom(aContent), aWidget,
      GetActionCauseName(aAction.mCause),
      GetActionFocusChangeName(aAction.mFocusChange)));
 
@@ -1069,17 +1064,17 @@ IMEStateManager::SetIMEState(const IMESt
 
 // static
 void
 IMEStateManager::SetInputContext(nsIWidget* aWidget,
                                  const InputContext& aInputContext,
                                  const InputContextAction& aAction)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::SetInputContext(aWidget=0x%p, aInputContext={ "
+    ("SetInputContext(aWidget=0x%p, aInputContext={ "
      "mIMEState={ mEnabled=%s, mOpen=%s }, mHTMLInputType=\"%s\", "
      "mHTMLInputInputmode=\"%s\", mActionHint=\"%s\" }, "
      "aAction={ mCause=%s, mAction=%s }), sActiveTabParent=0x%p",
      aWidget,
      GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
      GetIMEStateSetOpenName(aInputContext.mIMEState.mOpen),
      NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputType).get(),
      NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputInputmode).get(),
@@ -1114,17 +1109,17 @@ IMEStateManager::DispatchCompositionEven
                    EventDispatchingCallback* aCallBack,
                    bool aIsSynthesized)
 {
   RefPtr<TabParent> tabParent =
     aEventTargetNode->IsContent() ?
       TabParent::GetFrom(aEventTargetNode->AsContent()) : nullptr;
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::DispatchCompositionEvent(aNode=0x%p, "
+    ("DispatchCompositionEvent(aNode=0x%p, "
      "aPresContext=0x%p, aCompositionEvent={ mMessage=%s, "
      "mNativeIMEContext={ mRawNativeIMEContext=0x%X, "
      "mOriginProcessID=0x%X }, mWidget(0x%p)={ "
      "GetNativeIMEContext()={ mRawNativeIMEContext=0x%X, "
      "mOriginProcessID=0x%X }, Destroyed()=%s }, "
      "mFlags={ mIsTrusted=%s, mPropagationStopped=%s } }, "
      "aIsSynthesized=%s), tabParent=%p",
      aEventTargetNode, aPresContext,
@@ -1153,17 +1148,17 @@ IMEStateManager::DispatchCompositionEven
     sTextCompositions->GetCompositionFor(aCompositionEvent);
   if (!composition) {
     // If synthesized event comes after delayed native composition events
     // for request of commit or cancel, we should ignore it.
     if (NS_WARN_IF(aIsSynthesized)) {
       return;
     }
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::DispatchCompositionEvent(), "
+      ("  DispatchCompositionEvent(), "
        "adding new TextComposition to the array"));
     MOZ_ASSERT(aCompositionEvent->mMessage == eCompositionStart);
     composition =
       new TextComposition(aPresContext, aEventTargetNode, tabParent,
                           aCompositionEvent);
     sTextCompositions->AppendElement(composition);
   }
 #ifdef DEBUG
@@ -1190,17 +1185,17 @@ IMEStateManager::DispatchCompositionEven
   //       destroy the TextComposition with synthesized compositionend event.
   if ((!aIsSynthesized ||
        composition->WasNativeCompositionEndEventDiscarded()) &&
       aCompositionEvent->CausesDOMCompositionEndEvent()) {
     TextCompositionArray::index_type i =
       sTextCompositions->IndexOf(aCompositionEvent->mWidget);
     if (i != TextCompositionArray::NoIndex) {
       MOZ_LOG(sISMLog, LogLevel::Debug,
-        ("ISM:   IMEStateManager::DispatchCompositionEvent(), "
+        ("  DispatchCompositionEvent(), "
          "removing TextComposition from the array since NS_COMPOSTION_END "
          "was dispatched"));
       sTextCompositions->ElementAt(i)->Destroy();
       sTextCompositions->RemoveElementAt(i);
     }
   }
 }
 
@@ -1230,17 +1225,17 @@ IMEStateManager::HandleSelectionEvent(ns
 {
   nsIContent* eventTargetContent =
     aEventTargetContent ? aEventTargetContent :
                           GetRootContent(aPresContext);
   RefPtr<TabParent> tabParent =
     eventTargetContent ? TabParent::GetFrom(eventTargetContent) : nullptr;
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::HandleSelectionEvent(aPresContext=0x%p, "
+    ("HandleSelectionEvent(aPresContext=0x%p, "
      "aEventTargetContent=0x%p, aSelectionEvent={ mMessage=%s, "
      "mFlags={ mIsTrusted=%s } }), tabParent=%p",
      aPresContext, aEventTargetContent,
      ToChar(aSelectionEvent->mMessage),
      GetBoolName(aSelectionEvent->mFlags.mIsTrusted),
      tabParent.get()));
 
   if (!aSelectionEvent->IsTrusted()) {
@@ -1265,17 +1260,17 @@ IMEStateManager::HandleSelectionEvent(ns
 void
 IMEStateManager::OnCompositionEventDiscarded(
                    WidgetCompositionEvent* aCompositionEvent)
 {
   // Note that this method is never called for synthesized events for emulating
   // commit or cancel composition.
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::OnCompositionEventDiscarded(aCompositionEvent={ "
+    ("OnCompositionEventDiscarded(aCompositionEvent={ "
      "mMessage=%s, mNativeIMEContext={ mRawNativeIMEContext=0x%X, "
      "mOriginProcessID=0x%X }, mWidget(0x%p)={ "
      "GetNativeIMEContext()={ mRawNativeIMEContext=0x%X, "
      "mOriginProcessID=0x%X }, Destroyed()=%s }, "
      "mFlags={ mIsTrusted=%s } })",
      ToChar(aCompositionEvent->mMessage),
      aCompositionEvent->mNativeIMEContext.mRawNativeIMEContext,
      aCompositionEvent->mNativeIMEContext.mOriginProcessID,
@@ -1298,17 +1293,17 @@ IMEStateManager::OnCompositionEventDisca
   RefPtr<TextComposition> composition =
     sTextCompositions->GetCompositionFor(aCompositionEvent->mWidget);
   if (!composition) {
     // If the PresShell has been being destroyed during composition,
     // a TextComposition instance for the composition was already removed from
     // the array and destroyed in OnDestroyPresContext().  Therefore, we may
     // fail to retrieve a TextComposition instance here.
     MOZ_LOG(sISMLog, LogLevel::Info,
-      ("ISM:   IMEStateManager::OnCompositionEventDiscarded(), "
+      ("  OnCompositionEventDiscarded(), "
        "TextComposition instance for the widget has already gone"));
     return;
   }
   composition->OnCompositionEventDiscarded(aCompositionEvent);
 }
 
 // static
 nsresult
@@ -1322,112 +1317,112 @@ IMEStateManager::NotifyIME(IMEMessage aM
 
 // static
 nsresult
 IMEStateManager::NotifyIME(const IMENotification& aNotification,
                            nsIWidget* aWidget,
                            bool aOriginIsRemote)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::NotifyIME(aNotification={ mMessage=%s }, "
+    ("NotifyIME(aNotification={ mMessage=%s }, "
      "aWidget=0x%p, aOriginIsRemote=%s), sFocusedIMEWidget=0x%p, "
      "sRemoteHasFocus=%s",
      ToChar(aNotification.mMessage), aWidget,
      GetBoolName(aOriginIsRemote), sFocusedIMEWidget,
      GetBoolName(sRemoteHasFocus)));
 
   if (NS_WARN_IF(!aWidget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::NotifyIME(), FAILED due to no widget"));
+      ("  NotifyIME(), FAILED due to no widget"));
     return NS_ERROR_INVALID_ARG;
   }
 
   switch (aNotification.mMessage) {
     case NOTIFY_IME_OF_FOCUS:
       if (sFocusedIMEWidget) {
         if (NS_WARN_IF(!sRemoteHasFocus && !aOriginIsRemote)) {
           MOZ_LOG(sISMLog, LogLevel::Error,
-            ("ISM:   IMEStateManager::NotifyIME(), although, this process is "
+            ("  NotifyIME(), although, this process is "
              "getting IME focus but there was focused IME widget"));
         } else {
           MOZ_LOG(sISMLog, LogLevel::Info,
-            ("ISM:   IMEStateManager::NotifyIME(), tries to notify IME of "
+            ("  NotifyIME(), tries to notify IME of "
              "blur first because remote process's blur notification hasn't "
              "been received yet..."));
         }
         nsCOMPtr<nsIWidget> focusedIMEWidget(sFocusedIMEWidget);
         sFocusedIMEWidget = nullptr;
         sRemoteHasFocus = false;
         focusedIMEWidget->NotifyIME(IMENotification(NOTIFY_IME_OF_BLUR));
       }
       sRemoteHasFocus = aOriginIsRemote;
       sFocusedIMEWidget = aWidget;
       return aWidget->NotifyIME(aNotification);
     case NOTIFY_IME_OF_BLUR: {
       if (!sRemoteHasFocus && aOriginIsRemote) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), received blur notification "
+          ("  NotifyIME(), received blur notification "
            "after another one has focus, nothing to do..."));
         return NS_OK;
       }
       if (NS_WARN_IF(sRemoteHasFocus && !aOriginIsRemote)) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received blur "
+          ("  NotifyIME(), FAILED, received blur "
            "notification from this process but the remote has focus"));
         return NS_OK;
       }
       if (!sFocusedIMEWidget && aOriginIsRemote) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), received blur notification "
+          ("  NotifyIME(), received blur notification "
            "but the remote has already lost focus"));
         return NS_OK;
       }
       if (NS_WARN_IF(!sFocusedIMEWidget)) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received blur "
+          ("  NotifyIME(), FAILED, received blur "
            "notification but there is no focused IME widget"));
         return NS_OK;
       }
       if (NS_WARN_IF(sFocusedIMEWidget != aWidget)) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received blur "
+          ("  NotifyIME(), FAILED, received blur "
            "notification but there is no focused IME widget"));
         return NS_OK;
       }
       nsCOMPtr<nsIWidget> focusedIMEWidget(sFocusedIMEWidget);
       sFocusedIMEWidget = nullptr;
       sRemoteHasFocus = false;
       return focusedIMEWidget->NotifyIME(IMENotification(NOTIFY_IME_OF_BLUR));
     }
     case NOTIFY_IME_OF_SELECTION_CHANGE:
     case NOTIFY_IME_OF_TEXT_CHANGE:
     case NOTIFY_IME_OF_POSITION_CHANGE:
     case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
       if (!sRemoteHasFocus && aOriginIsRemote) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), received content change "
+          ("  NotifyIME(), received content change "
            "notification from the remote but it's already lost focus"));
         return NS_OK;
       }
       if (NS_WARN_IF(sRemoteHasFocus && !aOriginIsRemote)) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received content "
+          ("  NotifyIME(), FAILED, received content "
            "change notification from this process but the remote has already "
            "gotten focus"));
         return NS_OK;
       }
       if (!sFocusedIMEWidget) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), received content change "
+          ("  NotifyIME(), received content change "
            "notification but there is no focused IME widget"));
         return NS_OK;
       }
       if (NS_WARN_IF(sFocusedIMEWidget != aWidget)) {
         MOZ_LOG(sISMLog, LogLevel::Error,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received content "
+          ("  NotifyIME(), FAILED, received content "
            "change notification for IME which has already lost focus, so, "
            "nothing to do..."));
         return NS_OK;
       }
       return aWidget->NotifyIME(aNotification);
     default:
       // Other notifications should be sent only when there is composition.
       // So, we need to handle the others below.
@@ -1438,37 +1433,37 @@ IMEStateManager::NotifyIME(const IMENoti
   if (sTextCompositions) {
     composition = sTextCompositions->GetCompositionFor(aWidget);
   }
 
   bool isSynthesizedForTests =
     composition && composition->IsSynthesizedForTests();
 
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM:   IMEStateManager::NotifyIME(), composition=0x%p, "
+    ("  NotifyIME(), composition=0x%p, "
      "composition->IsSynthesizedForTests()=%s",
      composition.get(), GetBoolName(isSynthesizedForTests)));
 
   switch (aNotification.mMessage) {
     case REQUEST_TO_COMMIT_COMPOSITION:
       return composition ?
         composition->RequestToCommit(aWidget, false) : NS_OK;
     case REQUEST_TO_CANCEL_COMPOSITION:
       return composition ?
         composition->RequestToCommit(aWidget, true) : NS_OK;
     case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
       if (!aOriginIsRemote && (!composition || isSynthesizedForTests)) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), FAILED, received content "
+          ("  NotifyIME(), FAILED, received content "
            "change notification from this process but there is no compostion"));
         return NS_OK;
       }
       if (!sRemoteHasFocus && aOriginIsRemote) {
         MOZ_LOG(sISMLog, LogLevel::Info,
-          ("ISM:   IMEStateManager::NotifyIME(), received content change "
+          ("  NotifyIME(), received content change "
            "notification from the remote but it's already lost focus"));
         return NS_OK;
       }
       return aWidget->NotifyIME(aNotification);
     default:
       MOZ_CRASH("Unsupported notification");
   }
   MOZ_CRASH(
@@ -1478,26 +1473,25 @@ IMEStateManager::NotifyIME(const IMENoti
 
 // static
 nsresult
 IMEStateManager::NotifyIME(IMEMessage aMessage,
                            nsPresContext* aPresContext,
                            bool aOriginIsRemote)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::NotifyIME(aMessage=%s, aPresContext=0x%p, "
-     "aOriginIsRemote=%s)",
+    ("NotifyIME(aMessage=%s, aPresContext=0x%p, aOriginIsRemote=%s)",
      ToChar(aMessage), aPresContext, GetBoolName(aOriginIsRemote)));
 
   NS_ENSURE_TRUE(aPresContext, NS_ERROR_INVALID_ARG);
 
   nsIWidget* widget = aPresContext->GetRootWidget();
   if (NS_WARN_IF(!widget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::NotifyIME(), FAILED due to no widget for the "
+      ("  NotifyIME(), FAILED due to no widget for the "
        "nsPresContext"));
     return NS_ERROR_NOT_AVAILABLE;
   }
   return NotifyIME(aMessage, widget, aOriginIsRemote);
 }
 
 // static
 bool
@@ -1554,72 +1548,71 @@ IMEStateManager::IsIMEObserverNeeded(con
   return aState.MaybeEditable();
 }
 
 // static
 void
 IMEStateManager::DestroyIMEContentObserver()
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::DestroyIMEContentObserver(), "
-     "sActiveIMEContentObserver=0x%p",
+    ("DestroyIMEContentObserver(), sActiveIMEContentObserver=0x%p",
      sActiveIMEContentObserver.get()));
 
   if (!sActiveIMEContentObserver) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::DestroyIMEContentObserver() does nothing"));
+      ("  DestroyIMEContentObserver() does nothing"));
     return;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Debug,
-    ("ISM:   IMEStateManager::DestroyIMEContentObserver(), destroying "
+    ("  DestroyIMEContentObserver(), destroying "
      "the active IMEContentObserver..."));
   RefPtr<IMEContentObserver> tsm = sActiveIMEContentObserver.get();
   sActiveIMEContentObserver = nullptr;
   tsm->Destroy();
 }
 
 // static
 void
 IMEStateManager::CreateIMEContentObserver(nsIEditor* aEditor)
 {
   MOZ_LOG(sISMLog, LogLevel::Info,
-    ("ISM: IMEStateManager::CreateIMEContentObserver(aEditor=0x%p), "
+    ("CreateIMEContentObserver(aEditor=0x%p), "
      "sPresContext=0x%p, sContent=0x%p, sActiveIMEContentObserver=0x%p, "
      "sActiveIMEContentObserver->IsManaging(sPresContext, sContent)=%s",
      aEditor, sPresContext, sContent.get(), sActiveIMEContentObserver.get(),
      GetBoolName(sActiveIMEContentObserver ?
        sActiveIMEContentObserver->IsManaging(sPresContext, sContent) : false)));
 
   if (NS_WARN_IF(sActiveIMEContentObserver)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::CreateIMEContentObserver(), FAILED due to "
+      ("  CreateIMEContentObserver(), FAILED due to "
        "there is already an active IMEContentObserver"));
     MOZ_ASSERT(sActiveIMEContentObserver->IsManaging(sPresContext, sContent));
     return;
   }
 
   nsCOMPtr<nsIWidget> widget = sPresContext->GetRootWidget();
   if (!widget) {
     MOZ_LOG(sISMLog, LogLevel::Error,
-      ("ISM:   IMEStateManager::CreateIMEContentObserver(), FAILED due to "
+      ("  CreateIMEContentObserver(), FAILED due to "
        "there is a root widget for the nsPresContext"));
     return; // Sometimes, there are no widgets.
   }
 
   // If it's not text editable, we don't need to create IMEContentObserver.
   if (!IsIMEObserverNeeded(widget->GetInputContext().mIMEState)) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
-      ("ISM:   IMEStateManager::CreateIMEContentObserver() doesn't create "
+      ("  CreateIMEContentObserver() doesn't create "
        "IMEContentObserver because of non-editable IME state"));
     return;
   }
 
   MOZ_LOG(sISMLog, LogLevel::Debug,
-    ("ISM:   IMEStateManager::CreateIMEContentObserver() is creating an "
+    ("  CreateIMEContentObserver() is creating an "
      "IMEContentObserver instance..."));
   sActiveIMEContentObserver = new IMEContentObserver();
 
   // IMEContentObserver::Init() might create another IMEContentObserver
   // instance.  So, sActiveIMEContentObserver would be replaced with new one.
   // We should hold the current instance here.
   RefPtr<IMEContentObserver> kungFuDeathGrip(sActiveIMEContentObserver);
   sActiveIMEContentObserver->Init(widget, sPresContext, sContent, aEditor);