// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/accessibility/platform/browser_accessibility_cocoa.h"

#include <optional>

#include "base/apple/foundation_util.h"
#include "base/check.h"
#include "base/command_line.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/sys_string_conversions.h"
#include "content/browser/accessibility/accessibility_test_helpers.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/common/content_switches.h"
#include "content/public/test/accessibility_notification_waiter.h"
#include "content/public/test/browser_test.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/content_browser_test.h"
#include "content/public/test/content_browser_test_utils.h"
#include "content/public/test/context_menu_interceptor.h"
#include "content/public/test/scoped_accessibility_mode_override.h"
#include "content/public/test/test_utils.h"
#include "content/shell/browser/shell.h"
#include "net/base/data_url.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/gtest_mac.h"
#include "ui/accessibility/ax_action_data.h"
#include "ui/accessibility/platform/ax_private_webkit_constants_mac.h"
#include "ui/accessibility/platform/ax_utils_mac.h"
#include "ui/accessibility/platform/browser_accessibility.h"
#include "ui/accessibility/platform/browser_accessibility_cocoa_test_helpers.h"
#include "ui/accessibility/platform/browser_accessibility_mac.h"
#include "ui/accessibility/platform/browser_accessibility_manager.h"
#include "ui/accessibility/platform/browser_accessibility_manager_mac.h"
#include "ui/accessibility/platform/inspect/ax_inspect_utils_mac.h"
#include "ui/accessibility/platform/test_ax_node_id_delegate.h"
#include "url/gurl.h"

namespace {

#include <string>

// Returns HTML that creates a 60-row table.
std::string GetLargeTableHTML() {
  return R"delim(data:text/html,
    <html>
      <head>
        <title>Large Table</title>
        <script type="text/javascript">

          function CreateTable() {
          const numColumns = 5;
          const numRows = 60;

          const table = document.createElement('table');
          for (let i = 0; i < numRows; i++) {
            const row = document.createElement('tr');
            for (let j = 0; j < numColumns; j++) {
              const cell = document.createElement('td');
              cell.textContent = `row ${i+1}, column ${j+1}`;
              row.appendChild(cell);
            }
            table.appendChild(row);
          }

          document.body.appendChild(table);
        }

        </script>
      </head>
      <body onLoad="CreateTable()">

      </body>
    </html>)delim";
}

// Returns the accessibility frame assigned to `element`.
NSRect GetAXFrame(AXUIElementRef element) {
  AXValueRef value;

  CGPoint position = CGPointZero;
  if (AXUIElementCopyAttributeValue(element, kAXPositionAttribute,
                                    (CFTypeRef*)&value) == kAXErrorSuccess) {
    if (AXValueGetType(value) == kAXValueCGPointType) {
      AXValueGetValue(value, (AXValueType)kAXValueCGPointType, &position);
      CFRelease(value);
    }
  }

  CGSize size = CGSizeZero;
  if (AXUIElementCopyAttributeValue(element, kAXSizeAttribute,
                                    (CFTypeRef*)&value) == kAXErrorSuccess) {
    if (AXValueGetType(value) == kAXValueCGSizeType) {
      AXValueGetValue(value, (AXValueType)kAXValueCGSizeType, &size);
      CFRelease(value);
    }
  }

  return NSMakeRect(position.x, position.y, size.width, size.height);
}

// Returns the string associated with `element`.
NSString* GetAXUIElementStringValue(AXUIElementRef element) {
  CFTypeRef value;
  NSString* stringValue = nil;

  if (AXUIElementCopyAttributeValue(element, kAXValueAttribute, &value) ==
      kAXErrorSuccess) {
    if (CFGetTypeID(value) == CFStringGetTypeID()) {
      stringValue = [NSString stringWithString:(__bridge NSString*)value];
    }
    CFRelease(value);
  }

  return stringValue;
}

}  // namespace

// A table cell as seen by an assitive technology when navigating a web page.
@interface ATTestTableCell : NSObject
@property(nonatomic) NSRect frame;
@property(nonatomic, strong) NSString* value;
- (instancetype)initFromElement:(AXUIElementRef)cellElement;
@end

@implementation ATTestTableCell
@synthesize frame = _frame;
@synthesize value = _value;

- (instancetype)initFromElement:(AXUIElementRef)cellElement {
  self = [super init];
  if (self) {
    _frame = GetAXFrame(cellElement);
    _value = GetAXUIElementStringValue(cellElement);
  }
  return self;
}
@end

// A table row as seen by an assitive technology when navigating a web page.
@interface ATTestTableRow : NSObject
@property(nonatomic) NSRect frame;
@property(nonatomic, strong) NSMutableArray<ATTestTableCell*>* cells;
- (instancetype)initFromElement:(AXUIElementRef)rowElement;
@end

@implementation ATTestTableRow
@synthesize frame = _frame;
@synthesize cells = _cells;

- (instancetype)initFromElement:(AXUIElementRef)rowElement {
  self = [super init];
  if (self) {
    _frame = GetAXFrame(rowElement);
    _cells = [NSMutableArray array];
    [self populateCellsFromRowElement:rowElement];
  }
  return self;
}

- (void)populateCellsFromRowElement:(AXUIElementRef)rowElement {
  CFArrayRef cellsArray = NULL;

  if (AXUIElementCopyAttributeValue(rowElement, kAXChildrenAttribute,
                                    (CFTypeRef*)&cellsArray) ==
          kAXErrorSuccess &&
      cellsArray) {
    CFIndex cellCount = CFArrayGetCount(cellsArray);

    for (CFIndex i = 0; i < cellCount; i++) {
      AXUIElementRef cellElement =
          (AXUIElementRef)CFArrayGetValueAtIndex(cellsArray, i);
      ATTestTableCell* cell =
          [[ATTestTableCell alloc] initFromElement:cellElement];
      [_cells addObject:cell];
    }

    CFRelease(cellsArray);
  }
}

@end

// A table as seen by an assitive technology when navigating a web page.
@interface AXTestTable : NSObject
@property(nonatomic, strong) NSMutableArray<ATTestTableRow*>* rows;
- (instancetype)initWithAXUIElement:(AXUIElementRef)tableElement;
@end

@implementation AXTestTable
@synthesize rows = _rows;

- (instancetype)initWithAXUIElement:(AXUIElementRef)tableElement {
  self = [super init];
  if (self) {
    _rows = [NSMutableArray array];
    [self populateTableFromElement:tableElement];
  }
  return self;
}

- (void)populateTableFromElement:(AXUIElementRef)tableElement {
  CFArrayRef rowsArray = NULL;

  if (AXUIElementCopyAttributeValue(tableElement, kAXRowsAttribute,
                                    (CFTypeRef*)&rowsArray) ==
          kAXErrorSuccess &&
      rowsArray) {
    CFIndex rowCount = CFArrayGetCount(rowsArray);

    for (CFIndex i = 0; i < rowCount; i++) {
      AXUIElementRef rowElement =
          (AXUIElementRef)CFArrayGetValueAtIndex(rowsArray, i);
      ATTestTableRow* row = [[ATTestTableRow alloc] initFromElement:rowElement];
      [_rows addObject:row];
    }

    CFRelease(rowsArray);
  }
}

@end

namespace content {

class BrowserAccessibilityCocoaBrowserTest : public ContentBrowserTest {
 public:
  BrowserAccessibilityCocoaBrowserTest() {}
  ~BrowserAccessibilityCocoaBrowserTest() override {}

 protected:
  void SetUpOnMainThread() override {
    accessibility_mode_.emplace(ui::kAXModeComplete);
  }

  void TearDownOnMainThread() override { accessibility_mode_.reset(); }

  ui::BrowserAccessibility* FindNode(ax::mojom::Role role) {
    ui::BrowserAccessibility* root =
        GetManager()->GetBrowserAccessibilityRoot();
    CHECK(root);
    return FindFirstAccessibilityNodeWithRole(*root, role);
  }

  ui::BrowserAccessibilityManager* GetManager() {
    WebContentsImpl* web_contents =
        static_cast<WebContentsImpl*>(shell()->web_contents());
    return web_contents->GetRootBrowserAccessibilityManager();
  }

  // Trigger a context menu for the provided element without showing it. Returns
  // the coordinates where the context menu was invoked (calculated based on
  // the provided element). These coordinates are relative to the RenderView
  // origin.
  gfx::Point TriggerContextMenuAndGetMenuLocation(
      NSAccessibilityElement* element,
      ContextMenuInterceptor* interceptor) {
    // accessibilityPerformAction is deprecated, but it's still used internally
    // by AppKit.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    [element accessibilityPerformAction:NSAccessibilityShowMenuAction];
    interceptor->Wait();

    blink::UntrustworthyContextMenuParams context_menu_params =
        interceptor->get_params();
    return gfx::Point(context_menu_params.x, context_menu_params.y);
#pragma clang diagnostic pop
  }

  void FocusAccessibilityElementAndWaitForFocusChange(
      NSAccessibilityElement* element) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    [element setAccessibilityFocused:YES];
#pragma clang diagnostic pop
    WaitForAccessibilityFocusChange();
  }

  NSDictionary* GetUserInfoForSelectedTextChangedNotification() {
    auto* manager =
        static_cast<ui::BrowserAccessibilityManagerMac*>(GetManager());
    return manager->GetUserInfoForSelectedTextChangedNotification();
  }

  ui::AXTextEdit GetTextEditForNodeId(int32_t id) {
    auto* manager =
        static_cast<ui::BrowserAccessibilityManagerMac*>(GetManager());
    return manager->text_edits_[id];
  }

  ui::TestAXNodeIdDelegate node_id_delegate_;

 private:
  std::optional<ScopedAccessibilityModeOverride> accessibility_mode_;
};

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       ATCanScrollLargeTable) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  // Load a large table.
  GURL url(GetLargeTableHTML());

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  pid_t pid = getpid();
  base::apple::ScopedCFTypeRef<AXUIElementRef> axApplication(
      AXUIElementCreateApplication(pid));
  base::apple::ScopedCFTypeRef<AXUIElementRef> table =
      ui::FindAXUIElement(axApplication.get(), "AXTable");

  ASSERT_TRUE(table);

  AXTestTable* axTable = [[AXTestTable alloc] initWithAXUIElement:table.get()];
  NSArray* rows = [axTable rows];

  EXPECT_TRUE(rows.count == 60);

  // A very tall table will have some number of cells hidden (clipped by its
  // container or the window). For VoiceOver and other ATs to work properly,
  // all rows and cells must have non-zero sizes, even if clipped.
  int rowNumber = 0;
  for (ATTestTableRow* row in rows) {
    EXPECT_FALSE(NSIsEmptyRect(row.frame))
        << "zero extent for row " << rowNumber;
    EXPECT_TRUE(row.cells.count);
    EXPECT_FALSE(NSIsEmptyRect(row.cells[0].frame))
        << "zero extent for row " << rowNumber << ", cell "
        << row.cells[0].value;

    rowNumber++;
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       AXTextMarkerForTextEdit) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  GURL url(R"HTML(data:text/html,
             <input />)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* text_field = FindNode(ax::mojom::Role::kTextField);
  ASSERT_NE(nullptr, text_field);
  EXPECT_TRUE(ExecJs(shell()->web_contents(),
                     "document.querySelector('input').focus()"));

  SimulateKeyPress(shell()->web_contents(), ui::DomKey::FromCharacter('B'),
                   ui::DomCode::US_B, ui::VKEY_B, false, false, false, false);

  BrowserAccessibilityCocoa* cocoa_text_field =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          text_field->GetNativeViewAccessible().Get());
  AccessibilityNotificationWaiter value_waiter(shell()->web_contents(),
                                               ax::mojom::Event::kValueChanged);
  ASSERT_TRUE(value_waiter.WaitForNotification());
  ui::AXTextEdit text_edit = [cocoa_text_field computeTextEdit];
  EXPECT_NE(text_edit.edit_text_marker, nil);

  auto ax_position = ui::AXTextMarkerToAXPosition(text_edit.edit_text_marker);
  std::string expected_string = "TextPosition anchor_id=";
  expected_string += base::NumberToString(ax_position->anchor_id());
  expected_string += " text_offset=1 affinity=downstream annotated_text=B<>";
  EXPECT_EQ(ax_position->ToString(), expected_string);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       AXTextMarkerForTextEditContentEditable) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  GURL url(R"HTML(data:text/html,
                  <div id="editable" contenteditable="true" dir="auto">
                    <p>One</p>
                    <p>Two</p>
                    <p><br></p>
                    <p>Three</p>
                    <p>Four</p>
                    <p>Five</p>
                  </div>)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* content_editable =
      GetManager()->GetBrowserAccessibilityRoot()->PlatformGetChild(0);
  ASSERT_NE(nullptr, content_editable);
  EXPECT_TRUE(ExecJs(shell()->web_contents(),
                     "document.querySelector('#editable').focus()"));
  {
    SimulateKeyPress(shell()->web_contents(), ui::DomKey::FromCharacter('B'),
                     ui::DomCode::US_B, ui::VKEY_B, false, false, false, false);

    AccessibilityNotificationWaiter value_waiter(
        shell()->web_contents(), ax::mojom::Event::kValueChanged);
    ASSERT_TRUE(value_waiter.WaitForNotification());

    ui::AXTextEdit text_edit = GetTextEditForNodeId(content_editable->GetId());
    EXPECT_NE(text_edit.edit_text_marker, nil);
    EXPECT_EQ(u"", text_edit.deleted_text);
    EXPECT_EQ(u"B", text_edit.inserted_text);

    auto ax_position = ui::AXTextMarkerToAXPosition(text_edit.edit_text_marker);
    std::string expected_string = "TextPosition anchor_id=";
    expected_string += base::NumberToString(ax_position->anchor_id());
    expected_string += " text_offset=0 affinity=downstream annotated_text=";
    expected_string += "<B>OneTwo\nThreeFourFive";

    EXPECT_EQ(ax_position->ToString(), expected_string);
  }

  // Move Cursor down to the fourth paragraph.
  for (int i = 0; i < 4; ++i) {
    SimulateKeyPressWithoutChar(shell()->web_contents(), ui::DomKey::ARROW_DOWN,
                                ui::DomCode::ARROW_DOWN, ui::VKEY_DOWN,
                                /*control=*/false, /*shift=*/false,
                                /*alt=*/false,
                                /*command=*/false);
  }
  {
    SimulateKeyPress(shell()->web_contents(), ui::DomKey::FromCharacter('B'),
                     ui::DomCode::US_B, ui::VKEY_B, false, false, false, false);

    AccessibilityNotificationWaiter value_waiter(
        shell()->web_contents(), ax::mojom::Event::kValueChanged);
    ASSERT_TRUE(value_waiter.WaitForNotification());

    ui::AXTextEdit text_edit = GetTextEditForNodeId(content_editable->GetId());
    EXPECT_NE(text_edit.edit_text_marker, nil);
    EXPECT_EQ(u"", text_edit.deleted_text);
    EXPECT_EQ(u"B", text_edit.inserted_text);
    auto ax_position = ui::AXTextMarkerToAXPosition(text_edit.edit_text_marker);
    std::string expected_string = "TextPosition anchor_id=";
    expected_string += base::NumberToString(ax_position->anchor_id());
    expected_string += " text_offset=14 affinity=downstream annotated_text=";
    expected_string += "BOneTwo\nThreeF<B>ourFive";

    EXPECT_EQ(ax_position->ToString(), expected_string);
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       AXCellForColumnAndRow) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  GURL url(R"HTML(data:text/html,
             <table>
               <thead style=display:block>
                 <tr>
                   <th>Name</th>
                   <th>LDAP</th>
                 </tr>
               </thead>
               <tbody style=display:block>
                 <tr>
                   <td>John Doe</td>
                   <td>johndoe@</td>
                 </tr>
                 <tr>
                   <td>Jenny Doe</td>
                   <td>jennydoe@</td>
                 </tr>
               </tbody>
             </table>)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* table = FindNode(ax::mojom::Role::kTable);
  ASSERT_NE(nullptr, table);
  BrowserAccessibilityCocoa* cocoa_table =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          table->GetNativeViewAccessible().Get());

  // Test AXCellForColumnAndRow for four coordinates
  for (unsigned col = 0; col < 2; col++) {
    for (unsigned row = 0; row < 2; row++) {
      BrowserAccessibilityCocoa* cell =
          [cocoa_table accessibilityCellForColumn:col row:row];

      // It should be a cell.
      EXPECT_NSEQ(@"AXCell", cell.accessibilityRole);

      // The column index and row index of the cell should match what we asked
      // for.
      EXPECT_NSEQ(NSMakeRange(col, 1), cell.accessibilityColumnIndexRange);
      EXPECT_NSEQ(NSMakeRange(row, 1), cell.accessibilityRowIndexRange);
    }
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestCoordinatesAreInScreenSpace) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(R"HTML(data:text/html, <p>Hello, world!</p>)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* text = FindNode(ax::mojom::Role::kStaticText);
  ASSERT_NE(nullptr, text);

  BrowserAccessibilityCocoa* cocoa_text =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          text->GetNativeViewAccessible().Get());
  ASSERT_NE(nil, cocoa_text);

  NSPoint position = cocoa_text.position.pointValue;

  NSSize size = cocoa_text.accessibilityFrame.size;
  NSRect frame = NSMakeRect(position.x, position.y, size.width, size.height);

  NSPoint p0_before = position;
  NSRect r0_before = [cocoa_text frameForRange:NSMakeRange(0, 5)];
  EXPECT_TRUE(CGRectContainsRect(frame, r0_before));

  // On macOS geometry accessibility attributes are expected to use the
  // screen coordinate system with the origin at the bottom left corner.
  // We need some creativity with testing this because it is challenging
  // to setup a text element with a precise screen position.
  //
  // Content shell's window is pinned to have an origin at (0, 0), so
  // when its height is changed the content's screen y-coordinate is
  // changed by the same amount (see below).
  //
  //      Y^      original
  //       |
  //       +--------------------------------------------+
  //       |                                            |
  //       |                                            |
  //       |                                            |
  //       |                                            |
  //     h +---------------------------+                |
  //       |      Content Shell        |                |
  //       |---------------------------|                |
  //     y |Hello, world               |                |
  //       |                           |                |
  //       |                           |          Screen|
  //       +---------------------------+----------------+-->
  //      0                                               X
  //
  //      Y^       content shell enlarged
  //       |
  //       +--------------------------------------------+
  //       |                                            |
  //       |                                            |
  //  h+dh +---------------------------+                |
  //       |      Content Shell        |                |
  //       |---------------------------|                |
  //  y+dh |Hello, world               |                |
  //       |                           |                |
  //       |                           |                |
  //       |                           |                |
  //       |                           |          Screen|
  //       +---------------------------+----------------+-->
  //      0                                               X
  //
  // This observation allows us to validate the returned
  // attribute values and catch the most glaring mistakes
  // in coordinate space handling.

  const int dh = 100;
  gfx::Size content_size = Shell::GetShellDefaultSize();
  content_size.Enlarge(0, dh);
  shell()->ResizeWebContentForTests(content_size);

  NSPoint p0_after = cocoa_text.position.pointValue;
  NSRect r0_after = [cocoa_text frameForRange:NSMakeRange(0, 5)];

  ASSERT_EQ(p0_before.y + dh, p0_after.y);
  ASSERT_EQ(r0_before.origin.y + dh, r0_after.origin.y);
  ASSERT_EQ(r0_before.size.height, r0_after.size.height);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestAnnotatedImageDescription) {
  std::vector<const char*> expected_descriptions;

  ui::AXTreeUpdate tree;
  tree.root_id = 1;
  tree.nodes.resize(11);
  tree.nodes[0].id = 1;
  tree.nodes[0].child_ids = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

  // If the status is EligibleForAnnotation and there's no existing label,
  // the description should be the discoverability string.
  tree.nodes[1].id = 2;
  tree.nodes[1].role = ax::mojom::Role::kImage;
  tree.nodes[1].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[1].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kEligibleForAnnotation);
  expected_descriptions.push_back(
      "To get missing image descriptions, open the context menu.");

  // If the status is EligibleForAnnotation, the discoverability string
  // should be appended to the existing name.
  tree.nodes[2].id = 3;
  tree.nodes[2].role = ax::mojom::Role::kImage;
  tree.nodes[2].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[2].SetName("ExistingLabel");
  tree.nodes[2].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kEligibleForAnnotation);
  expected_descriptions.push_back(
      "ExistingLabel. To get missing image descriptions, open the context "
      "menu.");

  // If the status is SilentlyEligibleForAnnotation, the discoverability string
  // should not be appended to the existing name.
  tree.nodes[3].id = 4;
  tree.nodes[3].role = ax::mojom::Role::kImage;
  tree.nodes[3].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[3].SetName("ExistingLabel");
  tree.nodes[3].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kSilentlyEligibleForAnnotation);
  expected_descriptions.push_back("ExistingLabel");

  // If the status is IneligibleForAnnotation, nothing should be appended.
  tree.nodes[4].id = 5;
  tree.nodes[4].role = ax::mojom::Role::kImage;
  tree.nodes[4].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[4].SetName("ExistingLabel");
  tree.nodes[4].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kIneligibleForAnnotation);
  expected_descriptions.push_back("ExistingLabel");

  // If the status is AnnotationPending, pending text should be appended
  // to the name.
  tree.nodes[5].id = 6;
  tree.nodes[5].role = ax::mojom::Role::kImage;
  tree.nodes[5].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[5].SetName("ExistingLabel");
  tree.nodes[5].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationPending);
  expected_descriptions.push_back("ExistingLabel. Getting description…");

  // If the status is AnnotationSucceeded, and there's no annotation,
  // nothing should be appended. (Ideally this shouldn't happen.)
  tree.nodes[6].id = 7;
  tree.nodes[6].role = ax::mojom::Role::kImage;
  tree.nodes[6].SetName("ExistingLabel");
  tree.nodes[6].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationSucceeded);
  expected_descriptions.push_back("ExistingLabel");

  // If the status is AnnotationSucceeded, the annotation should be appended
  // to the existing label.
  tree.nodes[7].id = 8;
  tree.nodes[7].role = ax::mojom::Role::kImage;
  tree.nodes[7].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[7].SetName("ExistingLabel");
  tree.nodes[7].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationSucceeded);
  expected_descriptions.push_back("ExistingLabel. Annotation");

  // If the status is AnnotationEmpty, failure text should be added to the
  // name.
  tree.nodes[8].id = 9;
  tree.nodes[8].role = ax::mojom::Role::kImage;
  tree.nodes[8].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[8].SetName("ExistingLabel");
  tree.nodes[8].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationEmpty);
  expected_descriptions.push_back("ExistingLabel. No description available.");

  // If the status is AnnotationAdult, appropriate text should be appended
  // to the name.
  tree.nodes[9].id = 10;
  tree.nodes[9].role = ax::mojom::Role::kImage;
  tree.nodes[9].AddStringAttribute(ax::mojom::StringAttribute::kImageAnnotation,
                                   "Annotation");
  tree.nodes[9].SetName("ExistingLabel");
  tree.nodes[9].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationAdult);
  expected_descriptions.push_back("ExistingLabel. Appears to contain adult "
                                  "content. No description available.");

  // If the status is AnnotationProcessFailed, failure text should be added
  // to the name.
  tree.nodes[10].id = 11;
  tree.nodes[10].role = ax::mojom::Role::kImage;
  tree.nodes[10].AddStringAttribute(
      ax::mojom::StringAttribute::kImageAnnotation, "Annotation");
  tree.nodes[10].SetName("ExistingLabel");
  tree.nodes[10].SetImageAnnotationStatus(
      ax::mojom::ImageAnnotationStatus::kAnnotationProcessFailed);
  expected_descriptions.push_back("ExistingLabel. No description available.");

  // We should have one expected description per child of the root.
  ASSERT_EQ(expected_descriptions.size(), tree.nodes[0].child_ids.size());
  int child_count = static_cast<int>(expected_descriptions.size());

  std::unique_ptr<ui::BrowserAccessibilityManagerMac> manager(
      new ui::BrowserAccessibilityManagerMac(tree, node_id_delegate_, nullptr));

  for (int child_index = 0; child_index < child_count; child_index++) {
    ui::BrowserAccessibility* child =
        manager->GetBrowserAccessibilityRoot()->PlatformGetChild(child_index);
    BrowserAccessibilityCocoa* child_obj =
        base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
            child->GetNativeViewAccessible().Get());

    EXPECT_NSEQ(base::SysUTF8ToNSString(expected_descriptions[child_index]),
                child_obj.accessibilityLabel);
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestTableGetRowNodesNestedRows) {
  // rootWebArea(#1)
  // ++grid(#2)
  // ++++row(#3)
  // ++++++columnHeader(#4)
  // ++++++columnHeader(#5)
  // ++++genericContainer(#6)
  // ++++++row(#7)
  // ++++++++cell(#8)
  // ++++++++cell(#9)
  // ++++++row(#10)
  // ++++++++cell(#11)
  // ++++++++cell(#12)

  ui::AXTreeUpdate tree;
  tree.root_id = 1;
  tree.nodes.resize(12);
  tree.nodes[0].id = 1;
  tree.nodes[0].role = ax::mojom::Role::kRootWebArea;
  tree.nodes[0].child_ids = {2};

  tree.nodes[1].id = 2;
  tree.nodes[1].role = ax::mojom::Role::kGrid;
  tree.nodes[1].child_ids = {3, 6};

  tree.nodes[2].id = 3;
  tree.nodes[2].role = ax::mojom::Role::kRow;
  tree.nodes[2].AddStringAttribute(ax::mojom::StringAttribute::kName, "row1");
  tree.nodes[2].child_ids = {4, 5};

  tree.nodes[3].id = 4;
  tree.nodes[3].role = ax::mojom::Role::kColumnHeader;
  tree.nodes[3].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                   "header1");

  tree.nodes[4].id = 5;
  tree.nodes[4].role = ax::mojom::Role::kColumnHeader;
  tree.nodes[4].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                   "header2");

  tree.nodes[5].id = 6;
  tree.nodes[5].role = ax::mojom::Role::kGenericContainer;
  tree.nodes[5].child_ids = {7, 10};

  tree.nodes[6].id = 7;
  tree.nodes[6].role = ax::mojom::Role::kRow;
  tree.nodes[6].AddStringAttribute(ax::mojom::StringAttribute::kName, "row2");
  tree.nodes[6].child_ids = {8, 9};

  tree.nodes[7].id = 8;
  tree.nodes[7].role = ax::mojom::Role::kCell;
  tree.nodes[7].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                   "cell1_row2");

  tree.nodes[8].id = 9;
  tree.nodes[8].role = ax::mojom::Role::kCell;
  tree.nodes[8].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                   "cell2_row2");

  tree.nodes[9].id = 10;
  tree.nodes[9].role = ax::mojom::Role::kRow;
  tree.nodes[9].AddStringAttribute(ax::mojom::StringAttribute::kName, "row3");
  tree.nodes[9].child_ids = {11, 12};

  tree.nodes[10].id = 11;
  tree.nodes[10].role = ax::mojom::Role::kCell;
  tree.nodes[10].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                    "cell1_row3");

  tree.nodes[11].id = 12;
  tree.nodes[11].role = ax::mojom::Role::kCell;
  tree.nodes[11].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                    "cell2_row3");

  std::unique_ptr<ui::BrowserAccessibilityManagerMac> manager(
      new ui::BrowserAccessibilityManagerMac(tree, node_id_delegate_, nullptr));

  ui::BrowserAccessibility* table =
      manager->GetBrowserAccessibilityRoot()->PlatformGetChild(0);
  BrowserAccessibilityCocoa* table_obj =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          table->GetNativeViewAccessible().Get());
  NSArray<BrowserAccessibilityCocoa*>* row_nodes = table_obj.accessibilityRows;

  EXPECT_EQ(3U, row_nodes.count);
  EXPECT_NSEQ(@"AXRow", [row_nodes[0] role]);
  EXPECT_NSEQ(@"row1", [row_nodes[0] accessibilityLabel]);

  EXPECT_NSEQ(@"AXRow", [row_nodes[1] role]);
  EXPECT_NSEQ(@"row2", [row_nodes[1] accessibilityLabel]);

  EXPECT_NSEQ(@"AXRow", [row_nodes[2] role]);
  EXPECT_NSEQ(@"row3", [row_nodes[2] accessibilityLabel]);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestTableGetRowNodesIndirectChildIds) {
  // rootWebArea(#1)
  // ++column(#2), indirectChildIds={3, 4}
  // ++row(#3)
  // ++row(#4)

  ui::AXTreeUpdate tree;
  tree.root_id = 1;
  tree.nodes.resize(4);

  tree.nodes[0].id = 1;
  tree.nodes[0].role = ax::mojom::Role::kRootWebArea;
  tree.nodes[0].child_ids = {2, 3, 4};

  tree.nodes[1].id = 2;
  tree.nodes[1].role = ax::mojom::Role::kColumn;
  tree.nodes[1].AddStringAttribute(ax::mojom::StringAttribute::kName,
                                   "column1");
  tree.nodes[1].AddIntListAttribute(
      ax::mojom::IntListAttribute::kIndirectChildIds,
      std::vector<int32_t>{3, 4});

  tree.nodes[2].id = 3;
  tree.nodes[2].role = ax::mojom::Role::kRow;
  tree.nodes[2].AddStringAttribute(ax::mojom::StringAttribute::kName, "row1");

  tree.nodes[3].id = 4;
  tree.nodes[3].role = ax::mojom::Role::kRow;
  tree.nodes[3].AddStringAttribute(ax::mojom::StringAttribute::kName, "row2");

  std::unique_ptr<ui::BrowserAccessibilityManagerMac> manager(
      new ui::BrowserAccessibilityManagerMac(tree, node_id_delegate_, nullptr));

  ui::BrowserAccessibility* column =
      manager->GetBrowserAccessibilityRoot()->PlatformGetChild(0);
  BrowserAccessibilityCocoa* col_obj =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          column->GetNativeViewAccessible().Get());
  EXPECT_NSEQ(@"AXColumn", col_obj.role);
  EXPECT_NSEQ(@"column1", col_obj.accessibilityLabel);

  NSArray<BrowserAccessibilityCocoa*>* row_nodes = col_obj.accessibilityRows;
  EXPECT_NSEQ(@"AXRow", [row_nodes[0] role]);
  EXPECT_NSEQ(@"row1", [row_nodes[0] accessibilityLabel]);

  EXPECT_NSEQ(@"AXRow", [row_nodes[1] role]);
  EXPECT_NSEQ(@"row2", [row_nodes[1] accessibilityLabel]);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestAXHeadersShouldOnlyIncludeColHeaders) {
  EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(
      R"HTML(data:text/html,
      <table aria-label="Population per country">
        <thead style=display:block>
          <tr>
            <th aria-label="Country">Country</th>
            <th aria-label="Population">Population</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td role=rowheader>Canada</td>
            <td>37</td>
          </tr>
          <tr>
            <td role=rowheader>USA</td>
            <td>331</td>
          </tr>
        </tbody>
      </table>
  )HTML");
  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* table = FindNode(ax::mojom::Role::kTable);
  BrowserAccessibilityCocoa* table_obj =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          table->GetNativeViewAccessible().Get());

  EXPECT_NSEQ(@"AXTable", table_obj.role);
  EXPECT_NSEQ(@"Population per country", table_obj.accessibilityLabel);
  BrowserAccessibilityCocoa* table_header = table_obj.header;

  NSArray<BrowserAccessibilityCocoa*>* children =
      table_header.accessibilityChildren;
  EXPECT_EQ(2U, children.count);

  EXPECT_NSEQ(@"AXCell", [children[0] role]);
  EXPECT_NSEQ(@"Country", [children[0] accessibilityLabel]);

  EXPECT_NSEQ(@"AXCell", [children[1] role]);
  EXPECT_NSEQ(@"Population", [children[1] accessibilityLabel]);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestTreeContextMenuEvent) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(R"HTML(data:text/html,
             <div alt="tree" role="tree">
               <div tabindex="1" role="treeitem">1</div>
               <div tabindex="2" role="treeitem">2</div>
             </div>)HTML");

  ASSERT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* tree = FindNode(ax::mojom::Role::kTree);
  BrowserAccessibilityCocoa* cocoa_tree =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tree->GetNativeViewAccessible().Get());

  NSArray<BrowserAccessibilityCocoa*>* tree_children =
      cocoa_tree.accessibilityChildren;
  ASSERT_NSEQ(@"AXRow", [tree_children[0] role]);
  ASSERT_NSEQ(@"AXRow", [tree_children[1] role]);

  auto menu_interceptor = std::make_unique<ContextMenuInterceptor>(
      shell()->web_contents()->GetPrimaryMainFrame(),
      ContextMenuInterceptor::ShowBehavior::kPreventShow);

  gfx::Point tree_point =
      TriggerContextMenuAndGetMenuLocation(cocoa_tree, menu_interceptor.get());

  menu_interceptor->Reset();
  gfx::Point item_2_point = TriggerContextMenuAndGetMenuLocation(
      tree_children[1], menu_interceptor.get());
  EXPECT_NE(tree_point, item_2_point);

  // Now focus the second child and trigger a context menu on the tree.
  ASSERT_TRUE(ExecJs(shell()->web_contents(),
                     "document.body.children[0].children[1].focus();"));
  WaitForAccessibilityFocusChange();

  // Triggering a context menu on the tree should now trigger the menu
  // on the focused child.
  menu_interceptor->Reset();
  gfx::Point new_point =
      TriggerContextMenuAndGetMenuLocation(cocoa_tree, menu_interceptor.get());
  EXPECT_EQ(new_point, item_2_point);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestEventRetargetingFocus) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(R"HTML(data:text/html,
             <div role="tree">
               <div tabindex="1" role="treeitem">1</div>
               <div tabindex="2" role="treeitem">2</div>
             </div>
             <div role="treegrid">
               <div tabindex="1" role="treeitem">1</div>
               <div tabindex="2" role="treeitem">2</div>
             </div>
             <div role="tablist">
               <div tabindex="1" role="tab">1</div>
               <div tabindex="2" role="tab">2</div>
             </div>
             <div role="table">
               <div tabindex="1" role="row">1</div>
               <div tabindex="2" role="row">2</div>
             </div>
             <div role="banner">
               <div tabindex="1" role="link">1</div>
               <div tabindex="2" role="link">2</div>
             </div>)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  std::pair<ax::mojom::Role, bool> tests[] = {
      std::make_pair(ax::mojom::Role::kTree, true),
      std::make_pair(ax::mojom::Role::kTreeGrid, true),
      std::make_pair(ax::mojom::Role::kTabList, true),
      std::make_pair(ax::mojom::Role::kTable, false),
      std::make_pair(ax::mojom::Role::kBanner, false),
  };

  for (auto& test : tests) {
    BrowserAccessibilityCocoa* parent =
        base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
            FindNode(test.first)->GetNativeViewAccessible().Get());
    BrowserAccessibilityCocoa* child = parent.accessibilityChildren[1];

    EXPECT_NE(nullptr, parent);
    EXPECT_EQ([child owner], [child actionTarget]);
    EXPECT_EQ([parent owner], [parent actionTarget]);

    FocusAccessibilityElementAndWaitForFocusChange(child);
    ASSERT_EQ(test.second, [parent actionTarget] == [child owner]);
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestEventRetargetingActiveDescendant) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(R"HTML(data:text/html,
             <div role="tree" aria-activedescendant="tree-child">
               <div tabindex="1" role="treeitem">1</div>
               <div id="tree-child" tabindex="2" role="treeitem">2</div>
             </div>
             <div role="treegrid" aria-activedescendant="treegrid-child">
               <div tabindex="1" role="treeitem">1</div>
               <div id="treegrid-child" tabindex="2" role="treeitem">2</div>
             </div>
             <div role="tablist" aria-activedescendant="tablist-child">
               <div tabindex="1" role="tab">1</div>
               <div id="tablist-child" tabindex="2" role="tab">2</div>
             </div>
             <div role="table" aria-activedescendant="table-child">
               <div tabindex="1" role="row">1</div>
               <div id="table-child" tabindex="2" role="row">2</div>
             </div>
             <div role="banner" aria-activedescendant="banner-child">
               <div tabindex="1" role="link">1</div>
               <div id="banner-child" tabindex="2" role="link">2</div>
             </div>)HTML");

  EXPECT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  std::pair<ax::mojom::Role, bool> tests[] = {
      std::make_pair(ax::mojom::Role::kTree, true),
      std::make_pair(ax::mojom::Role::kTreeGrid, true),
      std::make_pair(ax::mojom::Role::kTabList, true),
      std::make_pair(ax::mojom::Role::kTable, false),
      std::make_pair(ax::mojom::Role::kBanner, false),
  };

  for (auto& test : tests) {
    BrowserAccessibilityCocoa* parent =
        base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
            FindNode(test.first)->GetNativeViewAccessible().Get());
    BrowserAccessibilityCocoa* first_child = parent.accessibilityChildren[0];
    BrowserAccessibilityCocoa* second_child = parent.accessibilityChildren[1];

    EXPECT_NE(nullptr, parent);
    EXPECT_EQ([second_child owner], [second_child actionTarget]);
    EXPECT_EQ(test.second, [second_child owner] == [parent actionTarget]);

    // aria-activedescendant should take priority over focus for determining if
    // an object is the action target.
    FocusAccessibilityElementAndWaitForFocusChange(first_child);
    EXPECT_EQ(test.second, [second_child owner] == [parent actionTarget]);
  }
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaBrowserTest,
                       TestNSAccessibilityTextChangeElement) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);

  GURL url(R"HTML(data:text/html,
                  <div id="editable" contenteditable="true" dir="auto">
                    <p>One</p>
                    <p>Two</p>
                    <p><br></p>
                    <p>Three</p>
                    <p>Four</p>
                  </div>)HTML");

  ASSERT_TRUE(NavigateToURL(shell(), url));
  ASSERT_TRUE(waiter.WaitForNotification());

  BrowserAccessibilityCocoa* content_editable =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          GetManager()
              ->GetBrowserAccessibilityRoot()
              ->PlatformGetChild(0)
              ->GetNativeViewAccessible()
              .Get());
  EXPECT_EQ(content_editable.accessibilityChildren.count, 5ul);

  WebContents* web_contents = shell()->web_contents();
  auto run_script_and_wait_for_selection_change =
      [web_contents](const char* script) {
        AccessibilityNotificationWaiter waiter(
            web_contents, ui::AXEventGenerator::Event::TEXT_SELECTION_CHANGED);
        ASSERT_TRUE(ExecJs(web_contents, script));
        ASSERT_TRUE(waiter.WaitForNotification());
      };

  FocusAccessibilityElementAndWaitForFocusChange(content_editable);

  run_script_and_wait_for_selection_change(R"script(
      let editable = document.getElementById('editable');
      const selection = window.getSelection();
      selection.collapse(editable.children[0].childNodes[0], 1);)script");

  // The focused node in the user info should be the keyboard focusable
  // ancestor.
  NSDictionary* info = GetUserInfoForSelectedTextChangedNotification();
  EXPECT_EQ(id{content_editable},
            [info objectForKey:ui::NSAccessibilityTextChangeElement]);

  AccessibilityNotificationWaiter waiter2(
      web_contents, ui::AXEventGenerator::Event::TEXT_SELECTION_CHANGED);
  run_script_and_wait_for_selection_change(R"script(
      let editable = document.getElementById('editable');
      const selection = window.getSelection();
      selection.collapse(editable.children[2].childNodes[0], 0);)script");

  // Even when the cursor is in the empty paragraph text node, the focused
  // object should be the keyboard focusable ancestor.
  info = GetUserInfoForSelectedTextChangedNotification();
  EXPECT_EQ(id{content_editable},
            [info objectForKey:ui::NSAccessibilityTextChangeElement]);
}

// Mac-only in-process coverage for accessibilityCustomActions. The Mac AX
// dump test cannot observe NSAccessibilityCustomAction values across the
// cross-process AX boundary (crbug.com/407816615).
class BrowserAccessibilityCocoaAriaActionsBrowserTest
    : public BrowserAccessibilityCocoaBrowserTest {
 public:
  void SetUpCommandLine(base::CommandLine* command_line) override {
    BrowserAccessibilityCocoaBrowserTest::SetUpCommandLine(command_line);
    command_line->AppendSwitchASCII(switches::kEnableBlinkFeatures,
                                    "AriaActions");
  }
};

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaAriaActionsBrowserTest,
                       AccessibilityCustomActionsExposed) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  ASSERT_TRUE(NavigateToURL(shell(), GURL(R"HTML(data:text/html,
      <div role="tab" id="my-tab" aria-actions="edit open delete">
        your-file-name.pdf
        <button id="edit">Edit</button>
        <button id="open">Open</button>
        <button id="delete">Delete</button>
      </div>)HTML")));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* tab = FindNode(ax::mojom::Role::kTab);
  ASSERT_NE(nullptr, tab);

  BrowserAccessibilityCocoa* cocoa_tab =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tab->GetNativeViewAccessible().Get());
  NSArray<NSAccessibilityCustomAction*>* actions =
      [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(3u, actions.count);
  EXPECT_NSEQ(@"Edit", actions[0].name);
  EXPECT_NSEQ(@"Open", actions[1].name);
  EXPECT_NSEQ(@"Delete", actions[2].name);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaAriaActionsBrowserTest,
                       AccessibilityCustomActionDispatchesToTarget) {
  AccessibilityNotificationWaiter load_waiter(shell()->web_contents(),
                                              ax::mojom::Event::kLoadComplete);
  ASSERT_TRUE(NavigateToURL(shell(), GURL(R"HTML(data:text/html,
      <div role="tab" id="my-tab" aria-actions="edit">
        your-file-name.pdf
        <button id="edit" onclick=
            "document.getElementById('edit').innerText = 'edit clicked';">
          Edit
        </button>
      </div>)HTML")));
  ASSERT_TRUE(load_waiter.WaitForNotification());

  ui::BrowserAccessibility* tab = FindNode(ax::mojom::Role::kTab);
  ASSERT_NE(nullptr, tab);

  BrowserAccessibilityCocoa* cocoa_tab =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tab->GetNativeViewAccessible().Get());
  NSArray<NSAccessibilityCustomAction*>* actions =
      [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(1u, actions.count);
  EXPECT_NSEQ(@"Edit", actions[0].name);

  // Invoking the handler should dispatch `kDoDefault` to the target, which
  // fires the button's onclick handler and mutates its accessible name.
  AccessibilityNotificationWaiter name_waiter(
      shell()->web_contents(), ui::AXEventGenerator::Event::NAME_CHANGED);
  EXPECT_TRUE(actions[0].handler());
  ASSERT_TRUE(name_waiter.WaitForNotification());

  // The action array re-derives names from the live AX tree, so the renamed
  // target's name should surface on the next query.
  actions = [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(1u, actions.count);
  EXPECT_NSEQ(@"edit clicked", actions[0].name);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaAriaActionsBrowserTest,
                       AccessibilityCustomActionsFilterEmptyNameTargets) {
  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  ASSERT_TRUE(NavigateToURL(shell(), GURL(R"HTML(data:text/html,
      <div role="tab" id="src" aria-actions="edit unnamed delete">
        Source
        <button id="edit">Edit</button>
        <button id="unnamed"></button>
        <button id="delete">Delete</button>
      </div>)HTML")));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* tab = FindNode(ax::mojom::Role::kTab);
  ASSERT_NE(nullptr, tab);

  BrowserAccessibilityCocoa* cocoa_tab =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tab->GetNativeViewAccessible().Get());
  NSArray<NSAccessibilityCustomAction*>* actions =
      [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(2u, actions.count);
  EXPECT_NSEQ(@"Edit", actions[0].name);
  EXPECT_NSEQ(@"Delete", actions[1].name);
}

IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaAriaActionsBrowserTest,
                       AccessibilityCustomActionsTrackTargetIdMutation) {
  AccessibilityNotificationWaiter load_waiter(shell()->web_contents(),
                                              ax::mojom::Event::kLoadComplete);
  ASSERT_TRUE(NavigateToURL(shell(), GURL(R"HTML(data:text/html,
      <div role="tab" id="my-tab" aria-actions="edit open">
        your-file-name.pdf
        <button id="edit">Edit</button>
        <button id="open">Open</button>
        <button id="close">Close</button>
      </div>)HTML")));
  ASSERT_TRUE(load_waiter.WaitForNotification());

  ui::BrowserAccessibility* tab = FindNode(ax::mojom::Role::kTab);
  ASSERT_NE(nullptr, tab);
  BrowserAccessibilityCocoa* cocoa_tab =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tab->GetNativeViewAccessible().Get());
  NSArray<NSAccessibilityCustomAction*>* actions =
      [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(2u, actions.count);
  EXPECT_NSEQ(@"Edit", actions[0].name);
  EXPECT_NSEQ(@"Open", actions[1].name);

  // Mutating the source element's `aria-actions` attribute should be reflected
  // in subsequent reads of `accessibilityCustomActions`. Signal the end of the
  // test on every frame after the mutation so that we know all pending AX
  // serializations have been processed before re-querying.
  ASSERT_TRUE(ExecJs(shell()->web_contents(),
                     "document.getElementById('my-tab')"
                     ".setAttribute('aria-actions', 'close');"));
  {
    AccessibilityNotificationWaiter eot_waiter(shell()->web_contents(),
                                               ax::mojom::Event::kEndOfTest);
    for (auto* host : CollectAllRenderFrameHosts(shell()->web_contents())) {
      ui::AXActionData action_data;
      action_data.action = ax::mojom::Action::kSignalEndOfTest;
      host->AccessibilityPerformAction(action_data);
    }
    ASSERT_TRUE(eot_waiter.WaitForNotification(/*all_frames=*/true));
  }

  actions = [cocoa_tab accessibilityCustomActions];
  ASSERT_NE(nil, actions);
  ASSERT_EQ(1u, actions.count);
  EXPECT_NSEQ(@"Close", actions[0].name);
}

// Verifies the runtime surface-isolation contract on the
// AXCustomActionNamesForTesting test attribute: when the runtime opt-in
// has not been called, a same-process direct query via
// -accessibilityAttributeValue: must NOT return projected custom-action
// names. See kAXCustomActionNamesForTestingAttribute in
// browser_accessibility_cocoa.mm for the contract.
//
// This fixture intentionally does not call
// ui::EnableAXCustomActionNamesForTestingProjection(); the dump-test
// base class is the only call site that does. Dump-test fixtures
// elsewhere cover the opt-in-enabled path.
IN_PROC_BROWSER_TEST_F(BrowserAccessibilityCocoaAriaActionsBrowserTest,
                       CustomActionNamesForTestingNotExposedWithoutOptIn) {
  ASSERT_FALSE(ui::IsAXCustomActionNamesForTestingProjectionEnabled())
      << "Test invariant: the runtime opt-in must not be set for this "
         "fixture. Did a previous test in the same process enable it?";

  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
                                         ax::mojom::Event::kLoadComplete);
  ASSERT_TRUE(NavigateToURL(shell(), GURL(R"HTML(data:text/html,
      <div role="tab" id="my-tab" aria-actions="edit open delete">
        your-file-name.pdf
        <button id="edit">Edit</button>
        <button id="open">Open</button>
        <button id="delete">Delete</button>
      </div>)HTML")));
  ASSERT_TRUE(waiter.WaitForNotification());

  ui::BrowserAccessibility* tab = FindNode(ax::mojom::Role::kTab);
  ASSERT_NE(nullptr, tab);
  BrowserAccessibilityCocoa* cocoa_tab =
      base::apple::ObjCCastStrict<BrowserAccessibilityCocoa>(
          tab->GetNativeViewAccessible().Get());

  // Sanity check: the underlying production accessor still works, so any
  // difference observed below is attributable to the runtime opt-in
  // contract rather than a stale tree.
  ASSERT_NE(nil, [cocoa_tab accessibilityCustomActions]);

  // Intentionally exercises the deprecated legacy NSAccessibility
  // attribute-by-string interface because that is exactly the surface
  // we are claiming is gated, and same-process callers (including
  // misbehaving production code) could still reach it.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
  // The test attribute must not be advertised to enumeration.
  NSArray* attribute_names = [cocoa_tab accessibilityAttributeNames];
  EXPECT_FALSE(
      [attribute_names containsObject:@"AXCustomActionNamesForTesting"])
      << "AXCustomActionNamesForTesting must not be enumerated when the "
         "runtime opt-in is not set.";

  // The selector itself must short-circuit to nil when the runtime opt-in
  // is not set, so direct same-process queries by string also see nothing.
  id value =
      [cocoa_tab accessibilityAttributeValue:@"AXCustomActionNamesForTesting"];
  EXPECT_EQ(nil, value)
      << "Direct -accessibilityAttributeValue: query for the test "
         "attribute must return nil when the runtime opt-in is not set.";
#pragma clang diagnostic pop
}

}  // namespace content
