Boolean properties for Accessibility Object Model Phase 1

third_party/WebKit/Source/modules/accessibility/AXRadioInput.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/accessibility/AXRadioInput.h"
 
 #include "core/InputTypeNames.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/forms/RadioInputType.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 20 matching lines @@
 }
 
 void AXRadioInput::UpdatePosAndSetSize(int position) {
   if (position)
     pos_in_set_ = position;
   set_size_ = SizeOfRadioGroup();
 }
 
 void AXRadioInput::RequestUpdateToNextNode(bool forward) {
   HTMLInputElement* next_element =
-      RadioInputType::NextRadioButtonInGroup(GetElement(), forward);
-  AXObjectImpl* next_a_xobject = AxObjectCache().Get(next_element);
-  if (!next_a_xobject || !next_a_xobject->IsAXRadioInput())
+      RadioInputType::NextRadioButtonInGroup(GetInputElement(), forward);
+  AXObjectImpl* next_axobject = AxObjectCache().Get(next_element);
+  if (!next_axobject || !next_axobject->IsAXRadioInput())
     return;
 
   int position = 0;
   if (forward)
     position = PosInSet() + 1;
   // If it is backward, it keeps position as positions are already assigned for
   // previous objects.  updatePosAndSetSize() is called with '0' and it doesn't
   // modify m_posInSet and updates m_setSize as size is increased.
 
-  ToAXRadioInput(next_a_xobject)->UpdatePosAndSetSize(position);
-  AxObjectCache().PostNotification(next_a_xobject,
+  ToAXRadioInput(next_axobject)->UpdatePosAndSetSize(position);
+  AxObjectCache().PostNotification(next_axobject,
                                    AXObjectCacheImpl::kAXAriaAttributeChanged);
-  ToAXRadioInput(next_a_xobject)->RequestUpdateToNextNode(forward);
+  ToAXRadioInput(next_axobject)->RequestUpdateToNextNode(forward);
 }
 
 HTMLInputElement* AXRadioInput::FindFirstRadioButtonInGroup(
     HTMLInputElement* current) const {
   while (HTMLInputElement* prev_element =
              RadioInputType::NextRadioButtonInGroup(current, false))
     current = prev_element;
   return current;
 }
 
 int AXRadioInput::PosInSet() const {
   if (HasAttribute(aria_posinsetAttr))
     return GetAttribute(aria_posinsetAttr).ToInt();
   return pos_in_set_;
 }
 
 int AXRadioInput::SetSize() const {
   if (HasAttribute(aria_setsizeAttr))
     return GetAttribute(aria_setsizeAttr).ToInt();
   return set_size_;
 }
 
 bool AXRadioInput::CalculatePosInSet() {
   // Calculate 'posInSet' attribute when AXRadioInputs need to be updated
   // as a new AXRadioInput Object is added or one of objects from RadioGroup is
   // removed.
   bool need_to_update_prev = false;
   int position = 1;
   HTMLInputElement* prev_element =
-      RadioInputType::NextRadioButtonInGroup(GetElement(), false);
+      RadioInputType::NextRadioButtonInGroup(GetInputElement(), false);
   if (prev_element) {
     AXObjectImpl* object = AxObjectCache().Get(prev_element);
     // If the previous element doesn't have AXObjectImpl yet, caculate position
     // from the first element.  Otherwise, get position from the previous
     // AXObjectImpl.
     if (!object || !object->IsAXRadioInput()) {
       position = CountFromFirstElement();
     } else {
       position = object->PosInSet() + 1;
       // It returns true if previous objects need to be updated.
       // When AX tree exists already and a new node is inserted,
       // as updating is started from the inserted node,
       // we need to update setSize for previous nodes.
       if (SetSize() != object->SetSize())
         need_to_update_prev = true;
     }
   }
   UpdatePosAndSetSize(position);
 
   // If it is not the last element, request update to the next node.
   if (position != SetSize())
     RequestUpdateToNextNode(true);
   return need_to_update_prev;
 }
 
 int AXRadioInput::CountFromFirstElement() const {
   int count = 1;
-  HTMLInputElement* current = GetElement();
+  HTMLInputElement* current = GetInputElement();
   while (HTMLInputElement* prev_element =
              RadioInputType::NextRadioButtonInGroup(current, false)) {
     current = prev_element;
     count++;
   }
   return count;
 }
 
-HTMLInputElement* AXRadioInput::GetElement() const {
+HTMLInputElement* AXRadioInput::GetInputElement() const {
   return toHTMLInputElement(layout_object_->GetNode());
 }
 
 int AXRadioInput::SizeOfRadioGroup() const {
-  int size = GetElement()->SizeOfRadioGroup();
+  int size = GetInputElement()->SizeOfRadioGroup();
   // If it has no size in Group, it means that there is only itself.
   if (!size)
     return 1;
   return size;
 }
 
 }  // namespace blink