Fixes for re-enabling more MSVC level 4 warnings: Source/core/ edition

Source/core/accessibility/AXRenderObject.cpp

 /*
 * Copyright (C) 2008 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 1360 matching lines @@
     return axObjectCache()->getOrCreate(firstChild);
 }
 
 AXObject* AXRenderObject::nextSibling() const
 {
     if (!m_renderer)
         return 0;
 
     RenderObject* nextSibling = 0;
 
-    RenderInline* inlineContinuation;
-    if (m_renderer->isRenderBlock() && (inlineContinuation = toRenderBlock(m_renderer)->inlineElementContinuation())) {
+    RenderInline* inlineContinuation = m_renderer->isRenderBlock() ? toRenderBlock(m_renderer)->inlineElementContinuation() : 0;
+    if (inlineContinuation) {
         // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's first child.
         nextSibling = firstChildConsideringContinuation(inlineContinuation);
     } else if (m_renderer->isAnonymousBlock() && lastChildHasContinuation(m_renderer)) {
         // Case 2: Anonymous block parent of the start of a continuation - skip all the way to
         // after the parent of the end, since everything in between will be linked up via the continuation.
         RenderObject* lastParent = endOfContinuations(toRenderBlock(m_renderer)->lastChild())->parent();
         while (lastChildHasContinuation(lastParent))
             lastParent = endOfContinuations(lastParent->slowLastChild())->parent();
         nextSibling = lastParent->nextSibling();
     } else if (RenderObject* ns = m_renderer->nextSibling()) {
@@ skipping 553 matching lines @@
         return true;
 
     return false;
 }
 
 RenderObject* AXRenderObject::renderParentObject() const
 {
     if (!m_renderer)
         return 0;
 
-    RenderObject* parent = m_renderer->parent();
-
-    RenderObject* startOfConts = 0;
-    RenderObject* firstChild = 0;
-    if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer))) {
+    RenderObject* startOfConts = m_renderer->isRenderBlock() ? startOfContinuations(m_renderer) : 0;
+    if (startOfConts) {
         // Case 1: node is a block and is an inline's continuation. Parent
         // is the start of the continuation chain.
-        parent = startOfConts;
-    } else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent))) {
+        return startOfConts;
+    }
+
+    RenderObject* parent = m_renderer->parent();
+    startOfConts = parent && parent->isRenderInline() ? startOfContinuations(parent) : 0;
+    if (startOfConts) {
         // Case 2: node's parent is an inline which is some node's continuation; parent is
         // the earliest node in the continuation chain.
-        parent = startOfConts;
-    } else if (parent && (firstChild = parent->slowFirstChild()) && firstChild->node()) {
+        return startOfConts;
+    }
+
+    RenderObject* firstChild = parent ? parent->slowFirstChild() : 0;
+    if (firstChild && firstChild->node()) {
         // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
         // Get the node's renderer and follow that continuation chain until the first child is found.
-        RenderObject* nodeRenderFirstChild = firstChild->node()->renderer();
-        while (nodeRenderFirstChild != firstChild) {
+        for (RenderObject* nodeRenderFirstChild = firstChild->node()->renderer(); nodeRenderFirstChild != firstChild; nodeRenderFirstChild = firstChild->node()->renderer()) {
             for (RenderObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
                 if (contsTest == firstChild) {
                     parent = nodeRenderFirstChild->parent();
                     break;
                 }
             }
             RenderObject* newFirstChild = parent->slowFirstChild();
             if (firstChild == newFirstChild)
                 break;
             firstChild = newFirstChild;
             if (!firstChild->node())
                 break;
-            nodeRenderFirstChild = firstChild->node()->renderer();
         }
     }
 
     return parent;
 }
 
 bool AXRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
 {
     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
         if (parent->node() && parent->node()->hasTagName(tagName))
@@ skipping 316 matching lines @@
         if (label && label->renderer()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace WebCore