A11y: Add/refactor methods for manipulating bitfields on AXNodeData.

content/browser/accessibility/browser_accessibility_win_unittest.cc

 // Copyright (c) 2012 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 "content/browser/accessibility/browser_accessibility_win.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 106 matching lines @@
 
 // Actual tests ---------------------------------------------------------------
 
 // Test that BrowserAccessibilityManager correctly releases the tree of
 // BrowserAccessibility instances upon delete.
 TEST_F(BrowserAccessibilityTest, TestNoLeaks) {
   // Create ui::AXNodeData objects for a simple document tree,
   // representing the accessibility information used to initialize
   // BrowserAccessibilityManager.
   ui::AXNodeData button;
+  button.ClearBitfields();
   button.id = 2;
   button.SetName("Button");
   button.role = ui::AX_ROLE_BUTTON;
-  button.state = 0;
 
   ui::AXNodeData checkbox;
+  checkbox.ClearBitfields();
   checkbox.id = 3;
   checkbox.SetName("Checkbox");
   checkbox.role = ui::AX_ROLE_CHECK_BOX;
-  checkbox.state = 0;
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.SetName("Document");
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = 0;
   root.child_ids.push_back(2);
   root.child_ids.push_back(3);
 
   // Construct a BrowserAccessibilityManager with this
   // ui::AXNodeData tree and a factory for an instance-counting
   // BrowserAccessibility, and ensure that exactly 3 instances were
   // created. Note that the manager takes ownership of the factory.
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
@@ skipping 32 matching lines @@
   ASSERT_EQ(1, CountedBrowserAccessibility::num_instances());
   child1_iaccessible->Release();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestChildrenChange) {
   // Create ui::AXNodeData objects for a simple document tree,
   // representing the accessibility information used to initialize
   // BrowserAccessibilityManager.
   ui::AXNodeData text;
+  text.ClearBitfields();
   text.id = 2;
   text.role = ui::AX_ROLE_STATIC_TEXT;
   text.SetName("old text");
-  text.state = 0;
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.SetName("Document");
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = 0;
   root.child_ids.push_back(2);
 
   // Construct a BrowserAccessibilityManager with this
   // ui::AXNodeData tree and a factory for an instance-counting
   // BrowserAccessibility.
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
           MakeAXTreeUpdate(root, text), nullptr,
           new CountedBrowserAccessibilityFactory()));
@@ skipping 53 matching lines @@
   // deleted.
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestChildrenChangeNoLeaks) {
   // Create ui::AXNodeData objects for a simple document tree,
   // representing the accessibility information used to initialize
   // BrowserAccessibilityManager.
   ui::AXNodeData div;
+  div.ClearBitfields();
   div.id = 2;
   div.role = ui::AX_ROLE_GROUP;
-  div.state = 0;
 
   ui::AXNodeData text3;
+  text3.ClearBitfields();
   text3.id = 3;
   text3.role = ui::AX_ROLE_STATIC_TEXT;
-  text3.state = 0;
 
   ui::AXNodeData text4;
+  text4.ClearBitfields();
   text4.id = 4;
   text4.role = ui::AX_ROLE_STATIC_TEXT;
-  text4.state = 0;
 
   div.child_ids.push_back(3);
   div.child_ids.push_back(4);
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = 0;
   root.child_ids.push_back(2);
 
   // Construct a BrowserAccessibilityManager with this
   // ui::AXNodeData tree and a factory for an instance-counting
   // BrowserAccessibility and ensure that exactly 4 instances were
   // created. Note that the manager takes ownership of the factory.
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
           MakeAXTreeUpdate(root, div, text3, text4), nullptr,
@@ skipping 22 matching lines @@
   std::string line1 = "One two three.";
   std::string line2 = "Four five six.";
   std::string text_value = line1 + '\n' + line2;
 
   ui::AXNodeData root;
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
   root.child_ids.push_back(2);
 
   ui::AXNodeData text_field;
+  text_field.ClearBitfields();
   text_field.id = 2;
   text_field.role = ui::AX_ROLE_TEXT_FIELD;
-  text_field.state = 1 << ui::AX_STATE_EDITABLE;
+  text_field.AddState(ui::AX_STATE_EDITABLE);
   text_field.SetValue(text_value);
   std::vector<int32_t> line_start_offsets;
   line_start_offsets.push_back(15);
   text_field.AddIntListAttribute(ui::AX_ATTR_CACHED_LINE_STARTS,
                                  line_start_offsets);
   text_field.child_ids.push_back(3);
   text_field.child_ids.push_back(5);
   text_field.child_ids.push_back(6);
 
   ui::AXNodeData static_text1;
+  static_text1.ClearBitfields();
   static_text1.id = 3;
   static_text1.role = ui::AX_ROLE_STATIC_TEXT;
-  static_text1.state = 1 << ui::AX_STATE_EDITABLE;
+  static_text1.AddState(ui::AX_STATE_EDITABLE);
   static_text1.SetName(line1);
   static_text1.child_ids.push_back(4);
 
   ui::AXNodeData inline_box1;
+  inline_box1.ClearBitfields();
   inline_box1.id = 4;
   inline_box1.role = ui::AX_ROLE_INLINE_TEXT_BOX;
-  inline_box1.state = 1 << ui::AX_STATE_EDITABLE;
+  inline_box1.AddState(ui::AX_STATE_EDITABLE);
   inline_box1.SetName(line1);
   std::vector<int32_t> word_start_offsets1;
   word_start_offsets1.push_back(0);
   word_start_offsets1.push_back(4);
   word_start_offsets1.push_back(8);
   inline_box1.AddIntListAttribute(
       ui::AX_ATTR_WORD_STARTS, word_start_offsets1);
 
   ui::AXNodeData line_break;
+  line_break.ClearBitfields();
   line_break.id = 5;
   line_break.role = ui::AX_ROLE_LINE_BREAK;
-  line_break.state = 1 << ui::AX_STATE_EDITABLE;
+  line_break.AddState(ui::AX_STATE_EDITABLE);
   line_break.SetName("\n");
 
   ui::AXNodeData static_text2;
+  static_text2.ClearBitfields();
   static_text2.id = 6;
   static_text2.role = ui::AX_ROLE_STATIC_TEXT;
-  static_text2.state = 1 << ui::AX_STATE_EDITABLE;
+  static_text2.AddState(ui::AX_STATE_EDITABLE);
   static_text2.SetName(line2);
   static_text2.child_ids.push_back(7);
 
   ui::AXNodeData inline_box2;
+  inline_box2.ClearBitfields();
   inline_box2.id = 7;
   inline_box2.role = ui::AX_ROLE_INLINE_TEXT_BOX;
-  inline_box2.state = 1 << ui::AX_STATE_EDITABLE;
+  inline_box2.AddState(ui::AX_STATE_EDITABLE);
   inline_box2.SetName(line2);
   std::vector<int32_t> word_start_offsets2;
   word_start_offsets2.push_back(0);
   word_start_offsets2.push_back(5);
   word_start_offsets2.push_back(10);
   inline_box2.AddIntListAttribute(
       ui::AX_ATTR_WORD_STARTS, word_start_offsets2);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
@@ skipping 91 matching lines @@
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestSimpleHypertext) {
   const std::string text1_name = "One two three.";
   const std::string text2_name = " Four five six.";
   const long text_name_len = text1_name.length() + text2_name.length();
 
   ui::AXNodeData text1;
+  text1.ClearBitfields();
   text1.id = 11;
   text1.role = ui::AX_ROLE_STATIC_TEXT;
-  text1.state = 1 << ui::AX_STATE_READ_ONLY;
+  text1.AddState(ui::AX_STATE_READ_ONLY);
   text1.SetName(text1_name);
 
   ui::AXNodeData text2;
+  text2.ClearBitfields();
   text2.id = 12;
   text2.role = ui::AX_ROLE_STATIC_TEXT;
-  text2.state = 1 << ui::AX_STATE_READ_ONLY;
+  text2.AddState(ui::AX_STATE_READ_ONLY);
   text2.SetName(text2_name);
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = 1 << ui::AX_STATE_READ_ONLY;
+  root.AddState(ui::AX_STATE_READ_ONLY);
   root.child_ids.push_back(text1.id);
   root.child_ids.push_back(text2.id);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
           MakeAXTreeUpdate(root, text1, text2), nullptr,
           new CountedBrowserAccessibilityFactory()));
   ASSERT_EQ(3, CountedBrowserAccessibility::num_instances());
 
@@ skipping 48 matching lines @@
   const base::string16 button_text_name = L"Red";
   const base::string16 link_text_name = L"Blue";
   // Each control (combo / check box, button and link) will be represented by an
   // embedded object character.
   const base::string16 embed(1, BrowserAccessibilityWin::kEmbeddedCharacter);
   const base::string16 root_hypertext =
       text1_name + embed + text2_name + embed + embed + embed;
   const long root_hypertext_len = root_hypertext.length();
 
   ui::AXNodeData text1;
+  text1.ClearBitfields();
   text1.id = 11;
   text1.role = ui::AX_ROLE_STATIC_TEXT;
-  text1.state = 1 << ui::AX_STATE_READ_ONLY;
+  text1.AddState(ui::AX_STATE_READ_ONLY);
   text1.SetName(base::UTF16ToUTF8(text1_name));
 
   ui::AXNodeData combo_box;
   combo_box.id = 12;
   combo_box.role = ui::AX_ROLE_COMBO_BOX;
   combo_box.SetName(base::UTF16ToUTF8(combo_box_name));
   combo_box.SetValue(base::UTF16ToUTF8(combo_box_value));
 
   ui::AXNodeData text2;
+  text2.ClearBitfields();
   text2.id = 13;
   text2.role = ui::AX_ROLE_STATIC_TEXT;
-  text2.state = 1 << ui::AX_STATE_READ_ONLY;
+  text2.AddState(ui::AX_STATE_READ_ONLY);
   text2.SetName(base::UTF16ToUTF8(text2_name));
 
   ui::AXNodeData check_box;
+  check_box.ClearBitfields();
   check_box.id = 14;
   check_box.role = ui::AX_ROLE_CHECK_BOX;
-  check_box.state = 0;
   check_box.AddIntAttribute(ui::AX_ATTR_CHECKED_STATE,
                             ui::AX_CHECKED_STATE_TRUE);
   check_box.SetName(base::UTF16ToUTF8(check_box_name));
   check_box.SetValue(base::UTF16ToUTF8(check_box_value));
 
   ui::AXNodeData button, button_text;
+  button.ClearBitfields();
+  button_text.ClearBitfields();
   button.id = 15;
   button_text.id = 17;
   button_text.SetName(base::UTF16ToUTF8(button_text_name));
   button.role = ui::AX_ROLE_BUTTON;
   button_text.role = ui::AX_ROLE_STATIC_TEXT;
-  button.state = 1 << ui::AX_STATE_READ_ONLY;
-  button_text.state = 1 << ui::AX_STATE_READ_ONLY;
+  button.AddState(ui::AX_STATE_READ_ONLY);
+  button_text.AddState(ui::AX_STATE_READ_ONLY);
   button.child_ids.push_back(button_text.id);
 
   ui::AXNodeData link, link_text;
+  link.ClearBitfields();
+  link_text.ClearBitfields();
   link.id = 16;
   link_text.id = 18;
   link_text.SetName(base::UTF16ToUTF8(link_text_name));
   link.role = ui::AX_ROLE_LINK;
   link_text.role = ui::AX_ROLE_STATIC_TEXT;
-  link.state = 1 << ui::AX_STATE_READ_ONLY;
-  link_text.state = 1 << ui::AX_STATE_READ_ONLY;
+  link.AddState(ui::AX_STATE_READ_ONLY);
+  link_text.AddState(ui::AX_STATE_READ_ONLY);
   link.child_ids.push_back(link_text.id);
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = 1 << ui::AX_STATE_READ_ONLY;
+  root.AddState(ui::AX_STATE_READ_ONLY);
   root.child_ids.push_back(text1.id);
   root.child_ids.push_back(combo_box.id);
   root.child_ids.push_back(text2.id);
   root.child_ids.push_back(check_box.id);
   root.child_ids.push_back(button.id);
   root.child_ids.push_back(link.id);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
@@ skipping 191 matching lines @@
   ui::AXNodeData pseudo_before;
   pseudo_before.id = 2;
   pseudo_before.role = ui::AX_ROLE_DIV;
   pseudo_before.AddStringAttribute(ui::AX_ATTR_HTML_TAG, "<pseudo:before>");
   pseudo_before.AddStringAttribute(ui::AX_ATTR_DISPLAY, "none");
 
   ui::AXNodeData checkbox;
   checkbox.id = 3;
   checkbox.SetName("Checkbox");
   checkbox.role = ui::AX_ROLE_CHECK_BOX;
-  checkbox.state = 0;
+  checkbox.ClearBitfields();
   checkbox.AddIntAttribute(ui::AX_ATTR_CHECKED_STATE,
                            ui::AX_CHECKED_STATE_TRUE);
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.SetName("Document");
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
   root.child_ids.push_back(2);
   root.child_ids.push_back(3);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
           MakeAXTreeUpdate(root, pseudo_before, checkbox), nullptr,
           new CountedBrowserAccessibilityFactory()));
   ASSERT_EQ(3, CountedBrowserAccessibility::num_instances());
 
@@ skipping 24 matching lines @@
   EXPECT_NE(nullptr, static_cast<BSTR>(attributes));
   attributes_str = std::wstring(attributes, attributes.Length());
   EXPECT_EQ(L"checkable:true;", attributes_str);
 
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestValueAttributeInTextControls) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData combo_box, combo_box_text;
+  combo_box.ClearBitfields();
+  combo_box_text.ClearBitfields();
   combo_box.id = 2;
   combo_box_text.id = 3;
   combo_box.SetName("Combo box:");
   combo_box_text.SetName("Combo box text");
   combo_box.role = ui::AX_ROLE_COMBO_BOX;
   combo_box_text.role = ui::AX_ROLE_STATIC_TEXT;
-  combo_box.state = (1 << ui::AX_STATE_EDITABLE) |
-                    (1 << ui::AX_STATE_FOCUSABLE);
-  combo_box_text.state = 1 << ui::AX_STATE_EDITABLE;
+  combo_box.AddState(ui::AX_STATE_EDITABLE);
+  combo_box.AddState(ui::AX_STATE_FOCUSABLE);
+  combo_box_text.AddState(ui::AX_STATE_EDITABLE);
   combo_box.child_ids.push_back(combo_box_text.id);
 
   ui::AXNodeData search_box, search_box_text, new_line;
+  search_box.ClearBitfields();
+  search_box_text.ClearBitfields();
+  new_line.ClearBitfields();
   search_box.id = 4;
   search_box_text.id = 5;
   new_line.id = 6;
   search_box.SetName("Search for:");
   search_box_text.SetName("Search box text");
   new_line.SetName("\n");
   search_box.role = ui::AX_ROLE_SEARCH_BOX;
   search_box_text.role = ui::AX_ROLE_STATIC_TEXT;
   new_line.role = ui::AX_ROLE_LINE_BREAK;
-  search_box.state = (1 << ui::AX_STATE_EDITABLE) |
-                     (1 << ui::AX_STATE_FOCUSABLE);
-  search_box_text.state = new_line.state = 1 << ui::AX_STATE_EDITABLE;
+  search_box.AddState(ui::AX_STATE_EDITABLE);
+  search_box.AddState(ui::AX_STATE_FOCUSABLE);
+  search_box_text.AddState(ui::AX_STATE_EDITABLE);
+  new_line.AddState(ui::AX_STATE_EDITABLE);
   search_box.child_ids.push_back(search_box_text.id);
   search_box.child_ids.push_back(new_line.id);
 
   ui::AXNodeData text_field;
+  text_field.ClearBitfields();
   text_field.id = 7;
   text_field.role = ui::AX_ROLE_TEXT_FIELD;
-  text_field.state =
-      (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_FOCUSABLE);
+  text_field.AddState(ui::AX_STATE_EDITABLE);
+  text_field.AddState(ui::AX_STATE_FOCUSABLE);
   text_field.SetValue("Text field text");
 
   ui::AXNodeData link, link_text;
+  link.ClearBitfields();
+  link_text.ClearBitfields();
   link.id = 8;
   link_text.id = 9;
   link_text.SetName("Link text");
   link.role = ui::AX_ROLE_LINK;
   link_text.role = ui::AX_ROLE_STATIC_TEXT;
-  link.state = link_text.state = 1 << ui::AX_STATE_READ_ONLY;
+  link.AddState(ui::AX_STATE_READ_ONLY);
+  link_text.AddState(ui::AX_STATE_READ_ONLY);
   link.child_ids.push_back(link_text.id);
 
   ui::AXNodeData slider, slider_text;
+  slider.ClearBitfields();
+  slider_text.ClearBitfields();
   slider.id = 10;
   slider_text.id = 11;
   slider.AddFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, 5.0F);
   slider_text.SetName("Slider text");
   slider.role = ui::AX_ROLE_SLIDER;
   slider_text.role = ui::AX_ROLE_STATIC_TEXT;
-  slider.state = slider_text.state = 1 << ui::AX_STATE_READ_ONLY;
+  slider.AddState(ui::AX_STATE_READ_ONLY);
+  slider_text.AddState(ui::AX_STATE_READ_ONLY);
   slider.child_ids.push_back(slider_text.id);
 
   root.child_ids.push_back(2);   // Combo box.
   root.child_ids.push_back(4);   // Search box.
   root.child_ids.push_back(7);   // Text field.
   root.child_ids.push_back(8);   // Link.
   root.child_ids.push_back(10);  // Slider.
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
@@ skipping 85 matching lines @@
   std::vector<int32_t> line2_word_starts;
   line2_word_starts.push_back(0);
   line2_word_starts.push_back(7);
   line2_word_starts.push_back(12);
   line2_word_starts.push_back(15);
   line2_word_starts.push_back(20);
   line2_word_starts.push_back(25);
   line2_word_starts.push_back(29);
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData textarea, textarea_div, textarea_text;
+  textarea.ClearBitfields();
+  textarea_div.ClearBitfields();
+  textarea_text.ClearBitfields();
   textarea.id = 2;
   textarea_div.id = 3;
   textarea_text.id = 4;
   textarea.role = ui::AX_ROLE_TEXT_FIELD;
   textarea_div.role = ui::AX_ROLE_DIV;
   textarea_text.role = ui::AX_ROLE_STATIC_TEXT;
-  textarea.state = (1 << ui::AX_STATE_EDITABLE) |
-                   (1 << ui::AX_STATE_FOCUSABLE) |
-                   (1 << ui::AX_STATE_MULTILINE);
-  textarea_div.state = 1 << ui::AX_STATE_EDITABLE;
-  textarea_text.state = 1 << ui::AX_STATE_EDITABLE;
+  textarea.AddState(ui::AX_STATE_EDITABLE);
+  textarea.AddState(ui::AX_STATE_FOCUSABLE);
+  textarea.AddState(ui::AX_STATE_MULTILINE);
+  textarea_div.AddState(ui::AX_STATE_EDITABLE);
+  textarea_text.AddState(ui::AX_STATE_EDITABLE);
   textarea.SetValue(base::UTF16ToUTF8(text));
   textarea_text.SetName(base::UTF16ToUTF8(text));
   textarea.AddStringAttribute(ui::AX_ATTR_HTML_TAG, "textarea");
   textarea.child_ids.push_back(textarea_div.id);
   textarea_div.child_ids.push_back(textarea_text.id);
 
   ui::AXNodeData textarea_line1, textarea_line2;
+  textarea_line1.ClearBitfields();
+  textarea_line2.ClearBitfields();
   textarea_line1.id = 5;
   textarea_line2.id = 6;
   textarea_line1.role = ui::AX_ROLE_INLINE_TEXT_BOX;
   textarea_line2.role = ui::AX_ROLE_INLINE_TEXT_BOX;
-  textarea_line1.state = 1 << ui::AX_STATE_EDITABLE;
-  textarea_line2.state = 1 << ui::AX_STATE_EDITABLE;
+  textarea_line1.AddState(ui::AX_STATE_EDITABLE);
+  textarea_line2.AddState(ui::AX_STATE_EDITABLE);
   textarea_line1.SetName(base::UTF16ToUTF8(line1));
   textarea_line2.SetName(base::UTF16ToUTF8(line2));
   textarea_line1.AddIntListAttribute(ui::AX_ATTR_WORD_STARTS,
                                      line1_word_starts);
   textarea_line2.AddIntListAttribute(ui::AX_ATTR_WORD_STARTS,
                                      line2_word_starts);
   textarea_text.child_ids.push_back(textarea_line1.id);
   textarea_text.child_ids.push_back(textarea_line2.id);
 
   ui::AXNodeData text_field, text_field_div, text_field_text;
+  text_field.ClearBitfields();
+  text_field_div.ClearBitfields();
+  text_field_text.ClearBitfields();
   text_field.id = 7;
   text_field_div.id = 8;
   text_field_text.id = 9;
   text_field.role = ui::AX_ROLE_TEXT_FIELD;
   text_field_div.role = ui::AX_ROLE_DIV;
   text_field_text.role = ui::AX_ROLE_STATIC_TEXT;
-  text_field.state =
-      (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_FOCUSABLE);
-  text_field_div.state = 1 << ui::AX_STATE_EDITABLE;
-  text_field_text.state = 1 << ui::AX_STATE_EDITABLE;
+  text_field.AddState(ui::AX_STATE_EDITABLE);
+  text_field.AddState(ui::AX_STATE_FOCUSABLE);
+  text_field_div.AddState(ui::AX_STATE_EDITABLE);
+  text_field_text.AddState(ui::AX_STATE_EDITABLE);
   text_field.SetValue(base::UTF16ToUTF8(line1));
   text_field_text.SetName(base::UTF16ToUTF8(line1));
   text_field.AddStringAttribute(ui::AX_ATTR_HTML_TAG, "input");
   text_field.html_attributes.push_back(std::make_pair("type", "text"));
   text_field.child_ids.push_back(text_field_div.id);
   text_field_div.child_ids.push_back(text_field_text.id);
 
   ui::AXNodeData text_field_line;
+  text_field_line.ClearBitfields();
   text_field_line.id = 10;
   text_field_line.role = ui::AX_ROLE_INLINE_TEXT_BOX;
-  text_field_line.state = 1 << ui::AX_STATE_EDITABLE;
+  text_field_line.AddState(ui::AX_STATE_EDITABLE);
   text_field_line.SetName(base::UTF16ToUTF8(line1));
   text_field_line.AddIntListAttribute(ui::AX_ATTR_WORD_STARTS,
                                       line1_word_starts);
   text_field_text.child_ids.push_back(text_field_line.id);
 
   root.child_ids.push_back(2);  // Textarea.
   root.child_ids.push_back(7);  // Text field.
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
@@ skipping 62 matching lines @@
 
   textarea_object.Reset();
   text_field_object.Reset();
 
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestCaretAndSelectionInSimpleFields) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData combo_box;
+  combo_box.ClearBitfields();
   combo_box.id = 2;
   combo_box.role = ui::AX_ROLE_COMBO_BOX;
-  combo_box.state = (1 << ui::AX_STATE_EDITABLE) |
-      (1 << ui::AX_STATE_FOCUSABLE);
+  combo_box.AddState(ui::AX_STATE_EDITABLE);
+  combo_box.AddState(ui::AX_STATE_FOCUSABLE);
   combo_box.SetValue("Test1");
   // Place the caret between 't' and 'e'.
   combo_box.AddIntAttribute(ui::AX_ATTR_TEXT_SEL_START, 1);
   combo_box.AddIntAttribute(ui::AX_ATTR_TEXT_SEL_END, 1);
 
   ui::AXNodeData text_field;
+  text_field.ClearBitfields();
   text_field.id = 3;
   text_field.role = ui::AX_ROLE_TEXT_FIELD;
-  text_field.state = (1 << ui::AX_STATE_EDITABLE) |
-      (1 << ui::AX_STATE_FOCUSABLE);
+  text_field.AddState(ui::AX_STATE_EDITABLE);
+  text_field.AddState(ui::AX_STATE_FOCUSABLE);
   text_field.SetValue("Test2");
   // Select the letter 'e'.
   text_field.AddIntAttribute(ui::AX_ATTR_TEXT_SEL_START, 1);
   text_field.AddIntAttribute(ui::AX_ATTR_TEXT_SEL_END, 2);
 
   root.child_ids.push_back(2);
   root.child_ids.push_back(3);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
@@ skipping 60 matching lines @@
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(1, selection_start);
   EXPECT_EQ(2, selection_end);
 
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestCaretInContentEditables) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData div_editable;
+  div_editable.ClearBitfields();
   div_editable.id = 2;
   div_editable.role = ui::AX_ROLE_DIV;
-  div_editable.state = (1 << ui::AX_STATE_EDITABLE) |
-      (1 << ui::AX_STATE_FOCUSABLE);
+  div_editable.AddState(ui::AX_STATE_EDITABLE);
+  div_editable.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData text;
+  text.ClearBitfields();
   text.id = 3;
   text.role = ui::AX_ROLE_STATIC_TEXT;
-  text.state = (1 << ui::AX_STATE_EDITABLE);
+  text.AddState(ui::AX_STATE_EDITABLE);
   text.SetName("Click ");
 
   ui::AXNodeData link;
+  link.ClearBitfields();
   link.id = 4;
   link.role = ui::AX_ROLE_LINK;
-  link.state = (1 << ui::AX_STATE_EDITABLE) |
-      (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_LINKED);
+  link.AddState(ui::AX_STATE_EDITABLE);
+  link.AddState(ui::AX_STATE_FOCUSABLE);
+  link.AddState(ui::AX_STATE_LINKED);
   link.SetName("here");
 
   ui::AXNodeData link_text;
+  link_text.ClearBitfields();
   link_text.id = 5;
   link_text.role = ui::AX_ROLE_STATIC_TEXT;
-  link_text.state = (1 << ui::AX_STATE_EDITABLE) |
-      (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_LINKED);
+  link_text.AddState(ui::AX_STATE_EDITABLE);
+  link_text.AddState(ui::AX_STATE_FOCUSABLE);
+  link_text.AddState(ui::AX_STATE_LINKED);
   link_text.SetName("here");
 
   root.child_ids.push_back(2);
   div_editable.child_ids.push_back(3);
   div_editable.child_ids.push_back(4);
   link.child_ids.push_back(5);
 
   ui::AXTreeUpdate update = MakeAXTreeUpdate(
       root, div_editable, link, link_text, text);
 
@@ skipping 73 matching lines @@
   hr = link_text_accessible->get_caretOffset(&caret_offset);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(1, caret_offset);
 
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestSelectionInContentEditables) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData div_editable;
+  div_editable.ClearBitfields();
   div_editable.id = 2;
   div_editable.role = ui::AX_ROLE_DIV;
-  div_editable.state =
-      (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_EDITABLE);
+  div_editable.AddState(ui::AX_STATE_FOCUSABLE);
+  div_editable.AddState(ui::AX_STATE_EDITABLE);
 
   ui::AXNodeData text;
+  text.ClearBitfields();
   text.id = 3;
   text.role = ui::AX_ROLE_STATIC_TEXT;
-  text.state = (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_EDITABLE);
+  text.AddState(ui::AX_STATE_FOCUSABLE);
+  text.AddState(ui::AX_STATE_EDITABLE);
   text.SetName("Click ");
 
   ui::AXNodeData link;
+  link.ClearBitfields();
   link.id = 4;
   link.role = ui::AX_ROLE_LINK;
-  link.state = (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_EDITABLE) |
-               (1 << ui::AX_STATE_LINKED);
+  link.AddState(ui::AX_STATE_FOCUSABLE);
+  link.AddState(ui::AX_STATE_EDITABLE);
+  link.AddState(ui::AX_STATE_LINKED);
   link.SetName("here");
 
   ui::AXNodeData link_text;
+  link_text.ClearBitfields();
   link_text.id = 5;
   link_text.role = ui::AX_ROLE_STATIC_TEXT;
-  link_text.state = (1 << ui::AX_STATE_FOCUSABLE) |
-                    (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_LINKED);
+  link_text.AddState(ui::AX_STATE_FOCUSABLE);
+  link_text.AddState(ui::AX_STATE_EDITABLE);
+  link_text.AddState(ui::AX_STATE_LINKED);
   link_text.SetName("here");
 
   root.child_ids.push_back(2);
   div_editable.child_ids.push_back(3);
   div_editable.child_ids.push_back(4);
   link.child_ids.push_back(5);
 
   ui::AXTreeUpdate update =
       MakeAXTreeUpdate(root, div_editable, link, link_text, text);
 
@@ skipping 107 matching lines @@
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(1, selection_start);
   EXPECT_EQ(7, selection_end);
 
   manager.reset();
   ASSERT_EQ(0, CountedBrowserAccessibility::num_instances());
 }
 
 TEST_F(BrowserAccessibilityTest, TestIAccessibleHyperlink) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData div;
+  div.ClearBitfields();
   div.id = 2;
   div.role = ui::AX_ROLE_DIV;
-  div.state = (1 << ui::AX_STATE_FOCUSABLE);
+  div.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData text;
+  text.ClearBitfields();
   text.id = 3;
   text.role = ui::AX_ROLE_STATIC_TEXT;
   text.SetName("Click ");
 
   ui::AXNodeData link;
+  link.ClearBitfields();
   link.id = 4;
   link.role = ui::AX_ROLE_LINK;
-  link.state = (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_LINKED);
+  link.AddState(ui::AX_STATE_FOCUSABLE);
+  link.AddState(ui::AX_STATE_LINKED);
   link.SetName("here");
   link.AddStringAttribute(ui::AX_ATTR_URL, "example.com");
 
   root.child_ids.push_back(2);
   div.child_ids.push_back(3);
   div.child_ids.push_back(4);
 
   CountedBrowserAccessibility::reset();
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(
@@ skipping 116 matching lines @@
   EXPECT_HRESULT_FAILED(root_accessible->get_endIndex(&end_index));
   EXPECT_HRESULT_SUCCEEDED(div_accessible->get_endIndex(&end_index));
   EXPECT_EQ(1, end_index);
   EXPECT_HRESULT_FAILED(text_accessible->get_endIndex(&end_index));
   EXPECT_HRESULT_SUCCEEDED(link_accessible->get_endIndex(&end_index));
   EXPECT_EQ(7, end_index);
 }
 
 TEST_F(BrowserAccessibilityTest, TestTextAttributesInContentEditables) {
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData div_editable;
+  div_editable.ClearBitfields();
   div_editable.id = 2;
   div_editable.role = ui::AX_ROLE_DIV;
-  div_editable.state =
-      (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_FOCUSABLE);
+  div_editable.AddState(ui::AX_STATE_EDITABLE);
+  div_editable.AddState(ui::AX_STATE_FOCUSABLE);
   div_editable.AddStringAttribute(ui::AX_ATTR_FONT_FAMILY, "Helvetica");
 
   ui::AXNodeData text_before;
+  text_before.ClearBitfields();
   text_before.id = 3;
   text_before.role = ui::AX_ROLE_STATIC_TEXT;
-  text_before.state = (1 << ui::AX_STATE_EDITABLE);
+  text_before.AddState(ui::AX_STATE_EDITABLE);
   text_before.SetName("Before ");
   text_before.AddIntAttribute(
       ui::AX_ATTR_TEXT_STYLE,
       (ui::AX_TEXT_STYLE_BOLD | ui::AX_TEXT_STYLE_ITALIC));
 
   ui::AXNodeData link;
+  link.ClearBitfields();
   link.id = 4;
   link.role = ui::AX_ROLE_LINK;
-  link.state = (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_FOCUSABLE) |
-               (1 << ui::AX_STATE_LINKED);
+  link.AddState(ui::AX_STATE_EDITABLE);
+  link.AddState(ui::AX_STATE_FOCUSABLE);
+  link.AddState(ui::AX_STATE_LINKED);
   link.SetName("lnk");
   link.AddIntAttribute(ui::AX_ATTR_TEXT_STYLE, ui::AX_TEXT_STYLE_UNDERLINE);
 
   ui::AXNodeData link_text;
+  link_text.ClearBitfields();
   link_text.id = 5;
   link_text.role = ui::AX_ROLE_STATIC_TEXT;
-  link_text.state = (1 << ui::AX_STATE_EDITABLE) |
-                    (1 << ui::AX_STATE_FOCUSABLE) | (1 << ui::AX_STATE_LINKED);
+  link_text.AddState(ui::AX_STATE_EDITABLE);
+  link_text.AddState(ui::AX_STATE_FOCUSABLE);
+  link_text.AddState(ui::AX_STATE_LINKED);
   link_text.SetName("lnk");
   link_text.AddIntAttribute(ui::AX_ATTR_TEXT_STYLE,
                             ui::AX_TEXT_STYLE_UNDERLINE);
 
   // The name "lnk" is misspelled.
   std::vector<int32_t> marker_types;
   marker_types.push_back(static_cast<int32_t>(ui::AX_MARKER_TYPE_SPELLING));
   std::vector<int32_t> marker_starts;
   marker_starts.push_back(0);
   std::vector<int32_t> marker_ends;
   marker_ends.push_back(3);
   link_text.AddIntListAttribute(ui::AX_ATTR_MARKER_TYPES, marker_types);
   link_text.AddIntListAttribute(ui::AX_ATTR_MARKER_STARTS, marker_starts);
   link_text.AddIntListAttribute(ui::AX_ATTR_MARKER_ENDS, marker_ends);
 
   ui::AXNodeData text_after;
+  text_after.ClearBitfields();
   text_after.id = 6;
   text_after.role = ui::AX_ROLE_STATIC_TEXT;
-  text_after.state = (1 << ui::AX_STATE_EDITABLE);
+  text_after.AddState(ui::AX_STATE_EDITABLE);
   text_after.SetName(" after.");
   // Leave text style as normal.
 
   root.child_ids.push_back(div_editable.id);
   div_editable.child_ids.push_back(text_before.id);
   div_editable.child_ids.push_back(link.id);
   div_editable.child_ids.push_back(text_after.id);
   link.child_ids.push_back(link_text.id);
 
   ui::AXTreeUpdate update = MakeAXTreeUpdate(root, div_editable, text_before,
@@ skipping 168 matching lines @@
 TEST_F(BrowserAccessibilityTest, TestMisspellingsInSimpleTextFields) {
   std::string value1("Testing .");
   // The word "helo" is misspelled.
   std::string value2("Helo there.");
 
   LONG value1_length = static_cast<LONG>(value1.length());
   LONG value2_length = static_cast<LONG>(value2.length());
   LONG combo_box_value_length = value1_length + value2_length;
 
   ui::AXNodeData root;
+  root.ClearBitfields();
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  root.state = (1 << ui::AX_STATE_READ_ONLY) | (1 << ui::AX_STATE_FOCUSABLE);
+  root.AddState(ui::AX_STATE_READ_ONLY);
+  root.AddState(ui::AX_STATE_FOCUSABLE);
 
   ui::AXNodeData combo_box;
+  combo_box.ClearBitfields();
   combo_box.id = 2;
   combo_box.role = ui::AX_ROLE_COMBO_BOX;
-  combo_box.state =
-      (1 << ui::AX_STATE_EDITABLE) | (1 << ui::AX_STATE_FOCUSABLE);
+  combo_box.AddState(ui::AX_STATE_EDITABLE);
+  combo_box.AddState(ui::AX_STATE_FOCUSABLE);
   combo_box.SetValue(value1 + value2);
 
   ui::AXNodeData combo_box_div;
+  combo_box_div.ClearBitfields();
   combo_box_div.id = 3;
   combo_box_div.role = ui::AX_ROLE_DIV;
-  combo_box_div.state = 1 << ui::AX_STATE_EDITABLE;
+  combo_box_div.AddState(ui::AX_STATE_EDITABLE);
 
   ui::AXNodeData static_text1;
+  static_text1.ClearBitfields();
   static_text1.id = 4;
   static_text1.role = ui::AX_ROLE_STATIC_TEXT;
-  static_text1.state = 1 << ui::AX_STATE_EDITABLE;
+  static_text1.AddState(ui::AX_STATE_EDITABLE);
   static_text1.SetName(value1);
 
   ui::AXNodeData static_text2;
+  static_text2.ClearBitfields();
   static_text2.id = 5;
   static_text2.role = ui::AX_ROLE_STATIC_TEXT;
-  static_text2.state = 1 << ui::AX_STATE_EDITABLE;
+  static_text2.AddState(ui::AX_STATE_EDITABLE);
   static_text2.SetName(value2);
 
   std::vector<int32_t> marker_types;
   marker_types.push_back(static_cast<int32_t>(ui::AX_MARKER_TYPE_SPELLING));
   std::vector<int32_t> marker_starts;
   marker_starts.push_back(0);
   std::vector<int32_t> marker_ends;
   marker_ends.push_back(4);
   static_text2.AddIntListAttribute(ui::AX_ATTR_MARKER_TYPES, marker_types);
   static_text2.AddIntListAttribute(ui::AX_ATTR_MARKER_STARTS, marker_starts);
@@ skipping 483 matching lines @@
   std::vector<AXEventNotificationDetails> events = {event};
   manager->OnAccessibilityEvents(events);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child1->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
   EXPECT_HRESULT_SUCCEEDED(ax_child2->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
 }
 
 }  // namespace content