DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 1435 matching lines @@
         return true;
     }
   }
 
   if (name == HTMLNames::classAttr) {
     const AtomicString& newClassString = newValue;
     if (classStringHasClassName(newClassString) ==
         ClassStringContent::HasClasses) {
       const SpaceSplitString& oldClasses = elementData()->classNames();
       const SpaceSplitString newClasses(
-          newClassString, document().inQuirksMode()
-                              ? SpaceSplitString::ShouldFoldCase
-                              : SpaceSplitString::ShouldNotFoldCase);
+          newClassString,
+          document().inQuirksMode() ? SpaceSplitString::ShouldFoldCase
+                                    : SpaceSplitString::ShouldNotFoldCase);
       if (featureSet.checkSelectorsForClassChange(oldClasses, newClasses))
         return true;
     } else {
       const SpaceSplitString& oldClasses = elementData()->classNames();
       if (featureSet.checkSelectorsForClassChange(oldClasses))
         return true;
     }
   }
 
   return featureSet.hasSelectorForAttribute(name.localName());
@@ skipping 653 matching lines @@
     return;
   if (ElementAnimations* elementAnimations =
           elementRareData()->elementAnimations())
     elementAnimations->setAnimationStyleChange(false);
 }
 
 void Element::setNeedsAnimationStyleRecalc() {
   if (getStyleChangeType() != NoStyleChange)
     return;
 
-  setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(
-                                            StyleChangeReason::Animation));
+  setNeedsStyleRecalc(
+      LocalStyleChange,
+      StyleChangeReasonForTracing::create(StyleChangeReason::Animation));
   setAnimationStyleChange(true);
 }
 
 void Element::setNeedsCompositingUpdate() {
   if (!document().isActive())
     return;
   LayoutBoxModelObject* layoutObject = layoutBoxModelObject();
   if (!layoutObject)
     return;
   if (!layoutObject->hasLayer())
@@ skipping 764 matching lines @@
   if (equalIgnoringCase(where, "afterEnd")) {
     if (ContainerNode* parent = this->parentNode()) {
       parent->insertBefore(newChild, nextSibling(), exceptionState);
       if (!exceptionState.hadException())
         return newChild;
     }
     return nullptr;
   }
 
   exceptionState.throwDOMException(
-      SyntaxError, "The value provided ('" + where +
-                       "') is not one of 'beforeBegin', 'afterBegin', "
-                       "'beforeEnd', or 'afterEnd'.");
+      SyntaxError,
+      "The value provided ('" + where +
+          "') is not one of 'beforeBegin', 'afterBegin', "
+          "'beforeEnd', or 'afterEnd'.");
   return nullptr;
 }
 
 ElementIntersectionObserverData* Element::intersectionObserverData() const {
   if (hasRareData())
     return elementRareData()->intersectionObserverData();
   return nullptr;
 }
 
 ElementIntersectionObserverData& Element::ensureIntersectionObserverData() {
@@ skipping 30 matching lines @@
       exceptionState.throwDOMException(NoModificationAllowedError,
                                        "The element has no parent.");
       return nullptr;
     }
     return parent;
   }
   if (equalIgnoringCase(where, "afterBegin") ||
       equalIgnoringCase(where, "beforeEnd"))
     return element;
   exceptionState.throwDOMException(
-      SyntaxError, "The value provided ('" + where +
-                       "') is not one of 'beforeBegin', 'afterBegin', "
-                       "'beforeEnd', or 'afterEnd'.");
+      SyntaxError,
+      "The value provided ('" + where +
+          "') is not one of 'beforeBegin', 'afterBegin', "
+          "'beforeEnd', or 'afterEnd'.");
   return nullptr;
 }
 
 Element* Element::insertAdjacentElement(const String& where,
                                         Element* newChild,
                                         ExceptionState& exceptionState) {
   Node* returnValue = insertAdjacent(where, newChild, exceptionState);
   return toElement(returnValue);
 }
 
@@ skipping 179 matching lines @@
 
   if (!pseudoElementSpecifier)
     return elementStyle;
 
   if (ComputedStyle* pseudoElementStyle =
           elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
     return pseudoElementStyle;
 
   RefPtr<ComputedStyle> result =
       document().ensureStyleResolver().pseudoStyleForElement(
-          this, PseudoStyleRequest(pseudoElementSpecifier,
-                                   PseudoStyleRequest::ForComputedStyle),
+          this,
+          PseudoStyleRequest(pseudoElementSpecifier,
+                             PseudoStyleRequest::ForComputedStyle),
           elementStyle);
   DCHECK(result);
   return elementStyle->addCachedPseudoStyle(result.release());
 }
 
 AtomicString Element::computeInheritedLanguage() const {
   const Node* n = this;
   AtomicString value;
   // The language property is inherited, so we iterate over the parents to find
   // the first language.
@@ skipping 25 matching lines @@
 
 void Element::cancelFocusAppearanceUpdate() {
   if (document().focusedElement() == this)
     document().cancelFocusAppearanceUpdate();
 }
 
 void Element::updatePseudoElement(PseudoId pseudoId, StyleRecalcChange change) {
   DCHECK(!needsStyleRecalc());
   PseudoElement* element = pseudoElement(pseudoId);
 
-  if (element && (change == UpdatePseudoElements ||
-                  element->shouldCallRecalcStyle(change))) {
+  if (element &&
+      (change == UpdatePseudoElements ||
+       element->shouldCallRecalcStyle(change))) {
     if (pseudoId == PseudoIdFirstLetter && updateFirstLetter(element))
       return;
 
     // Need to clear the cached style if the PseudoElement wants a recalc so it
     // computes a new style.
     if (element->needsStyleRecalc())
       layoutObject()->mutableStyle()->removeCachedPseudoStyle(pseudoId);
 
     // PseudoElement styles hang off their parent element's style so if we
     // needed a style recalc we should Force one on the pseudo.  FIXME: We
@@ skipping 670 matching lines @@
   elementData()->m_styleAttributeIsDirty = false;
 
   setNeedsStyleRecalc(
       LocalStyleChange,
       StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
   InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 void Element::inlineStyleChanged() {
   DCHECK(isStyledElement());
-  setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(
-                                            StyleChangeReason::Inline));
+  setNeedsStyleRecalc(
+      LocalStyleChange,
+      StyleChangeReasonForTracing::create(StyleChangeReason::Inline));
   DCHECK(elementData());
   elementData()->m_styleAttributeIsDirty = true;
   InspectorInstrumentation::didInvalidateStyleAttr(this);
 
   if (MutationObserverInterestGroup* recipients =
           MutationObserverInterestGroup::createForAttributesMutation(
               *this, styleAttr)) {
     // We don't use getAttribute() here to get a style attribute value
     // before the change.
     AtomicString oldValue;
@@ skipping 210 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink