Continue nit cleanup in fwl/core

xfa/fwl/core/cfwl_widgetmgr.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fwl/core/cfwl_widgetmgr.h"
 
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
@@ skipping 39 matching lines @@
   return pItem && pItem->pParent ? pItem->pParent->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetOwnerWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   return pItem && pItem->pOwner ? pItem->pOwner->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetFirstSiblingWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
-  pItem = pItem ? pItem->pPrevious : nullptr;  // Not self.
+  if (!pItem)
+    return nullptr;
+
+  pItem = pItem->pPrevious;
   while (pItem && pItem->pPrevious)
     pItem = pItem->pPrevious;
-
   return pItem ? pItem->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetPriorSiblingWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   return pItem && pItem->pPrevious ? pItem->pPrevious->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetNextSiblingWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   return pItem && pItem->pNext ? pItem->pNext->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetFirstChildWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   return pItem && pItem->pChild ? pItem->pChild->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetLastChildWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
-  pItem = pItem ? pItem->pChild : nullptr;
+  if (!pItem)
+    return nullptr;
+
+  pItem = pItem->pChild;
   while (pItem && pItem->pNext)
     pItem = pItem->pNext;
-
   return pItem ? pItem->pWidget : nullptr;
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetSystemFormWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   while (pItem) {
     if (IsAbleNative(pItem->pWidget))
       return pItem->pWidget;
     pItem = pItem->pParent;
   }
   return nullptr;
 }
 
 void CFWL_WidgetMgr::SetWidgetIndex(IFWL_Widget* pWidget, int32_t nIndex) {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   if (!pItem)
     return;
   if (!pItem->pParent)
     return;
+
   CFWL_WidgetMgrItem* pChild = pItem->pParent->pChild;
   int32_t i = 0;
   while (pChild) {
     if (pChild == pItem) {
       if (i == nIndex)
         return;
-      if (pChild->pPrevious) {
+      if (pChild->pPrevious)
         pChild->pPrevious->pNext = pChild->pNext;
-      }
-      if (pChild->pNext) {
+      if (pChild->pNext)
         pChild->pNext->pPrevious = pChild->pPrevious;
-      }
-      if (pItem->pParent->pChild == pItem) {
+      if (pItem->pParent->pChild == pItem)
         pItem->pParent->pChild = pItem->pNext;
-      }
+
       pItem->pNext = nullptr;
       pItem->pPrevious = nullptr;
       break;
     }
-    if (!pChild->pNext) {
+    if (!pChild->pNext)
       break;
-    }
+
     pChild = pChild->pNext;
     ++i;
   }
+
   pChild = pItem->pParent->pChild;
   if (pChild) {
     if (nIndex < 0) {
-      while (pChild->pNext) {
+      while (pChild->pNext)
         pChild = pChild->pNext;
-      }
+
       pChild->pNext = pItem;
       pItem->pPrevious = pChild;
       pItem->pNext = nullptr;
       return;
     }
+
     i = 0;
     while (i < nIndex && pChild->pNext) {
       pChild = pChild->pNext;
       ++i;
     }
     if (!pChild->pNext) {
       pChild->pNext = pItem;
       pItem->pPrevious = pChild;
       pItem->pNext = nullptr;
       return;
     }
     if (pChild->pPrevious) {
       pItem->pPrevious = pChild->pPrevious;
       pChild->pPrevious->pNext = pItem;
     }
     pChild->pPrevious = pItem;
     pItem->pNext = pChild;
-    if (pItem->pParent->pChild == pChild) {
+    if (pItem->pParent->pChild == pChild)
       pItem->pParent->pChild = pItem;
-    }
   } else {
     pItem->pParent->pChild = pItem;
     pItem->pPrevious = nullptr;
     pItem->pNext = nullptr;
   }
 }
 
 void CFWL_WidgetMgr::RepaintWidget(IFWL_Widget* pWidget,
                                    const CFX_RectF* pRect) {
   if (!m_pAdapter)
@@ skipping 25 matching lines @@
 void CFWL_WidgetMgr::InsertWidget(IFWL_Widget* pParent,
                                   IFWL_Widget* pChild,
                                   int32_t nIndex) {
   CFWL_WidgetMgrItem* pParentItem = GetWidgetMgrItem(pParent);
   if (!pParentItem) {
     pParentItem = new CFWL_WidgetMgrItem(pParent);
     m_mapWidgetItem[pParent].reset(pParentItem);
     pParentItem->pParent = GetWidgetMgrItem(nullptr);
     SetWidgetIndex(pParent, -1);
   }
+
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pChild);
   if (!pItem) {
     pItem = new CFWL_WidgetMgrItem(pChild);
     m_mapWidgetItem[pChild].reset(pItem);
   }
   if (pItem->pParent && pItem->pParent != pParentItem) {
-    if (pItem->pPrevious) {
+    if (pItem->pPrevious)
       pItem->pPrevious->pNext = pItem->pNext;
-    }
-    if (pItem->pNext) {
+    if (pItem->pNext)
       pItem->pNext->pPrevious = pItem->pPrevious;
-    }
-    if (pItem->pParent->pChild == pItem) {
+    if (pItem->pParent->pChild == pItem)
       pItem->pParent->pChild = pItem->pNext;
-    }
   }
   pItem->pParent = pParentItem;
   SetWidgetIndex(pChild, nIndex);
 }
+
 void CFWL_WidgetMgr::RemoveWidget(IFWL_Widget* pWidget) {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
-  if (!pItem) {
+  if (!pItem)
     return;
-  }
-  if (pItem->pPrevious) {
+  if (pItem->pPrevious)
     pItem->pPrevious->pNext = pItem->pNext;
-  }
-  if (pItem->pNext) {
+  if (pItem->pNext)
     pItem->pNext->pPrevious = pItem->pPrevious;
-  }
-  if (pItem->pParent && pItem->pParent->pChild == pItem) {
+  if (pItem->pParent && pItem->pParent->pChild == pItem)
     pItem->pParent->pChild = pItem->pNext;
-  }
+
   CFWL_WidgetMgrItem* pChild = pItem->pChild;
   while (pChild) {
     CFWL_WidgetMgrItem* pNext = pChild->pNext;
     RemoveWidget(pChild->pWidget);
     pChild = pNext;
   }
   m_mapWidgetItem.erase(pWidget);
 }
+
 void CFWL_WidgetMgr::SetOwner(IFWL_Widget* pOwner, IFWL_Widget* pOwned) {
   CFWL_WidgetMgrItem* pParentItem = GetWidgetMgrItem(pOwner);
   if (!pParentItem) {
     pParentItem = new CFWL_WidgetMgrItem(pOwner);
     m_mapWidgetItem[pOwner].reset(pParentItem);
     pParentItem->pParent = GetWidgetMgrItem(nullptr);
     SetWidgetIndex(pOwner, -1);
   }
+
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pOwned);
   if (!pItem) {
     pItem = new CFWL_WidgetMgrItem(pOwned);
     m_mapWidgetItem[pOwned].reset(pItem);
   }
   pItem->pOwner = pParentItem;
 }
 void CFWL_WidgetMgr::SetParent(IFWL_Widget* pParent, IFWL_Widget* pChild) {
   CFWL_WidgetMgrItem* pParentItem = GetWidgetMgrItem(pParent);
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pChild);
   if (!pItem)
     return;
   if (pItem->pParent && pItem->pParent != pParentItem) {
-    if (pItem->pPrevious) {
+    if (pItem->pPrevious)
       pItem->pPrevious->pNext = pItem->pNext;
-    }
-    if (pItem->pNext) {
+    if (pItem->pNext)
       pItem->pNext->pPrevious = pItem->pPrevious;
-    }
-    if (pItem->pParent->pChild == pItem) {
+    if (pItem->pParent->pChild == pItem)
       pItem->pParent->pChild = pItem->pNext;
-    }
+
     pItem->pNext = nullptr;
     pItem->pPrevious = nullptr;
   }
   pItem->pParent = pParentItem;
   SetWidgetIndex(pChild, -1);
 }
 
 void CFWL_WidgetMgr::SetWidgetRect_Native(IFWL_Widget* pWidget,
                                           const CFX_RectF& rect) {
-  if (FWL_UseOffscreen(pWidget)) {
-    CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
-    pItem->iRedrawCounter++;
-    if (pItem->pOffscreen) {
-      CFX_RenderDevice* pDevice = pItem->pOffscreen->GetRenderDevice();
-      if (pDevice && pDevice->GetBitmap()) {
-        CFX_DIBitmap* pBitmap = pDevice->GetBitmap();
-        if (pBitmap->GetWidth() - rect.width > 1 ||
-            pBitmap->GetHeight() - rect.height > 1) {
-          pItem->pOffscreen.reset();
-        }
+  if (!FWL_UseOffscreen(pWidget))
+    return;
+
+  CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
+  pItem->iRedrawCounter++;
+  if (pItem->pOffscreen) {
+    CFX_RenderDevice* pDevice = pItem->pOffscreen->GetRenderDevice();
+    if (pDevice && pDevice->GetBitmap()) {
+      CFX_DIBitmap* pBitmap = pDevice->GetBitmap();
+      if (pBitmap->GetWidth() - rect.width > 1 ||
+          pBitmap->GetHeight() - rect.height > 1) {
+        pItem->pOffscreen.reset();
       }
     }
+  }
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_) || (_FX_OS_ == _FX_WIN64_)
-    pItem->bOutsideChanged = !m_rtScreen.Contains(rect);
+  pItem->bOutsideChanged = !m_rtScreen.Contains(rect);
 #endif
-  }
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetWidgetAtPoint(IFWL_Widget* parent,
                                               FX_FLOAT x,
                                               FX_FLOAT y) {
   if (!parent)
     return nullptr;
+
   FX_FLOAT x1;
   FX_FLOAT y1;
   IFWL_Widget* child = GetLastChildWidget(parent);
   while (child) {
     if ((child->GetStates() & FWL_WGTSTATE_Invisible) == 0) {
       x1 = x;
       y1 = y;
       CFX_Matrix matrixOnParent;
       child->GetMatrix(matrixOnParent);
       CFX_Matrix m;
@@ skipping 57 matching lines @@
   IFWL_Widget* pNext = pRadioButton;
   if (pNext && (pNext->GetStyles() & FWL_WGTSTYLE_Group))
     return pNext;
   return nullptr;
 }
 
 void CFWL_WidgetMgr::GetSameGroupRadioButton(
     IFWL_Widget* pRadioButton,
     CFX_ArrayTemplate<IFWL_Widget*>& group) const {
   IFWL_Widget* pFirst = GetFirstSiblingWidget(pRadioButton);
-  if (!pFirst) {
+  if (!pFirst)
     pFirst = pRadioButton;
-  }
+
   int32_t iGroup = CountRadioButtonGroup(pFirst);
   if (iGroup < 2)
     return;
   group.Add(GetRadioButtonGroupHeader(pRadioButton));
 }
 
 IFWL_Widget* CFWL_WidgetMgr::GetDefaultButton(IFWL_Widget* pParent) const {
   if ((pParent->GetClassID() == FWL_Type::PushButton) &&
       (pParent->GetStates() & (1 << (FWL_WGTSTATE_MAX + 2)))) {
     return pParent;
   }
+
   IFWL_Widget* child =
       pParent->GetOwnerApp()->GetWidgetMgr()->GetFirstChildWidget(pParent);
   while (child) {
     if ((child->GetClassID() == FWL_Type::PushButton) &&
         (child->GetStates() & (1 << (FWL_WGTSTATE_MAX + 2)))) {
       return child;
     }
-    IFWL_Widget* find = GetDefaultButton(child);
-    if (find) {
+    if (IFWL_Widget* find = GetDefaultButton(child))
       return find;
-    }
+
     child = child->GetOwnerApp()->GetWidgetMgr()->GetNextSiblingWidget(child);
   }
   return nullptr;
 }
 
 void CFWL_WidgetMgr::AddRedrawCounts(IFWL_Widget* pWidget) {
   GetWidgetMgrItem(pWidget)->iRedrawCounter++;
 }
 
 void CFWL_WidgetMgr::ResetRedrawCounts(IFWL_Widget* pWidget) {
   GetWidgetMgrItem(pWidget)->iRedrawCounter = 0;
 }
 
 CFWL_WidgetMgrItem* CFWL_WidgetMgr::GetWidgetMgrItem(
     IFWL_Widget* pWidget) const {
   auto it = m_mapWidgetItem.find(pWidget);
   return it != m_mapWidgetItem.end()
              ? static_cast<CFWL_WidgetMgrItem*>(it->second.get())
              : nullptr;
 }
 
 bool CFWL_WidgetMgr::IsAbleNative(IFWL_Widget* pWidget) const {
   if (!pWidget)
     return false;
-  if (!pWidget->IsInstance(FX_WSTRC(FWL_CLASS_Form))) {
+  if (!pWidget->IsInstance(FX_WSTRC(FWL_CLASS_Form)))
     return false;
-  }
+
   uint32_t dwStyles = pWidget->GetStyles();
   return ((dwStyles & FWL_WGTSTYLE_WindowTypeMask) ==
           FWL_WGTSTYLE_OverLapper) ||
          (dwStyles & FWL_WGTSTYLE_Popup);
 }
 
 void CFWL_WidgetMgr::GetAdapterPopupPos(IFWL_Widget* pWidget,
                                         FX_FLOAT fMinHeight,
                                         FX_FLOAT fMaxHeight,
                                         const CFX_RectF& rtAnchor,
@@ skipping 43 matching lines @@
 void CFWL_WidgetMgr::OnDrawWidget(IFWL_Widget* pWidget,
                                   CFX_Graphics* pGraphics,
                                   const CFX_Matrix* pMatrix) {
   if (!pWidget || !pGraphics)
     return;
 
   CFX_Graphics* pTemp = DrawWidgetBefore(pWidget, pGraphics, pMatrix);
   CFX_RectF clipCopy;
   pWidget->GetWidgetRect(clipCopy);
   clipCopy.left = clipCopy.top = 0;
+
   if (UseOffscreenDirect(pWidget)) {
     DrawWidgetAfter(pWidget, pGraphics, clipCopy, pMatrix);
     return;
   }
   CFX_RectF clipBounds;
 
 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_ || \
     _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_ANDROID_
   pWidget->GetDelegate()->OnDrawWidget(pTemp, pMatrix);
   pGraphics->GetClipRect(clipBounds);
@@ skipping 54 matching lines @@
       clipBounds.Intersect(rtClip);
       if (clipBounds.IsEmpty())
         continue;
 
       pGraphics->SaveGraphState();
       pGraphics->SetClipRect(clipBounds);
     }
     widgetMatrix.Translate(rtWidget.left, rtWidget.top, true);
 
     if (IFWL_WidgetDelegate* pDelegate = child->GetDelegate()) {
-      if (IsFormDisabled() || IsNeedRepaint(child, &widgetMatrix, rtClip)) {
+      if (IsFormDisabled() || IsNeedRepaint(child, &widgetMatrix, rtClip))
         pDelegate->OnDrawWidget(pGraphics, &widgetMatrix);
-      }
     }
     if (!bFormDisable)
       pGraphics->RestoreGraphState();
 
     DrawChild(child, clipBounds, pGraphics,
               bFormDisable ? &widgetMatrix : pMatrix);
     child = GetNextSiblingWidget(child);
   }
 }
 
@@ skipping 34 matching lines @@
 }
 
 bool CFWL_WidgetMgr::IsNeedRepaint(IFWL_Widget* pWidget,
                                    CFX_Matrix* pMatrix,
                                    const CFX_RectF& rtDirty) {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   if (pItem && pItem->iRedrawCounter > 0) {
     pItem->iRedrawCounter = 0;
     return true;
   }
+
   CFX_RectF rtWidget;
   pWidget->GetWidgetRect(rtWidget);
   rtWidget.left = rtWidget.top = 0;
   pMatrix->TransformRect(rtWidget);
   if (!rtWidget.IntersectWith(rtDirty))
     return false;
 
   IFWL_Widget* pChild =
       pWidget->GetOwnerApp()->GetWidgetMgr()->GetFirstChildWidget(pWidget);
   if (!pChild)
@@ skipping 110 matching lines @@
       pWidget(widget),
       iRedrawCounter(0)
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_) || (_FX_OS_ == _FX_WIN64_)
       ,
       bOutsideChanged(false)
 #endif
 {
 }
 
 CFWL_WidgetMgrItem::~CFWL_WidgetMgrItem() {}