cl format

ui/accessibility/platform/ax_platform_node_mac.mm

 // Copyright 2014 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.
 
 #import "ui/accessibility/platform/ax_platform_node_mac.h"
 
 #import <Cocoa/Cocoa.h>
 #include <stddef.h>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ui/accessibility/ax_action_data.h"
 #include "ui/accessibility/ax_node_data.h"
+#include "ui/accessibility/ax_node_position.h"
+#include "ui/accessibility/ax_range.h"
 #include "ui/accessibility/ax_role_properties.h"
 #include "ui/accessibility/platform/ax_platform_node.h"
 #include "ui/accessibility/platform/ax_platform_node_delegate.h"
+#import "ui/accessibility/platform/text_marker_helper_mac.h"
 #include "ui/base/l10n/l10n_util.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #include "ui/strings/grit/ui_strings.h"
 
 namespace {
 
 struct RoleMapEntry {
   ui::AXRole value;
   NSString* nativeValue;
 };
@@ skipping 187 matching lines @@
       // TODO(patricialor): Add more events.
   };
 
   EventMap event_map;
   for (size_t i = 0; i < arraysize(events); ++i)
     event_map[events[i].value] = events[i].nativeValue;
   return event_map;
 }
 
 void NotifyMacEvent(AXPlatformNodeCocoa* target, ui::AXEvent event_type) {
+  NSLog(@"Notify: %@, %@", target,
+        [AXPlatformNodeCocoa nativeNotificationFromAXEvent:event_type]);
   NSAccessibilityPostNotification(
       target, [AXPlatformNodeCocoa nativeNotificationFromAXEvent:event_type]);
 }
 
 }  // namespace
 
+namespace ui {
+namespace {
+
+using AXNodePositionInstance = AXNodePosition::AXPositionInstance;
+using AXNodeRange = AXRange<AXNodePositionInstance::element_type>;
+
+class NodePositionFactory : public ui::PositionFactory {
+ public:
+  explicit NodePositionFactory(AXPlatformNodeCocoa* node) : node_(node) {}
+
+  ui::AXPositionPointer GetRoot() const override;
+  ui::AXRangePointer GetSelection() const override;
+  ui::AXPositionPointer GetFromData(
+      const ui::AXPositionData& data) const override;
+  id GetAccessibilityObject(const ui::AXPositionData& data) const override;
+
+ private:
+  AXPlatformNodeCocoa* node_;  // Weak. Transitively owns |this|.
+
+  DISALLOW_COPY_AND_ASSIGN(NodePositionFactory);
+};
+
+AXNodeRange CreateRangeFromTextMarkerRange(id marker_range) {
+  ui::AXPositionData start, end;
+  if (![TextMarkerHelperMac getRangeDataFromMarkerRange:marker_range
+                                                  start:&start
+                                                    end:&end]) {
+    return AXNodeRange();
+  }
+
+  return AXNodeRange(AXNodePosition::CreateFromData(start),
+                     AXNodePosition::CreateFromData(end));
+}
+
+NSString* GetTextForTextMarkerRange(id marker_range) {
+  AXNodeRange range = CreateRangeFromTextMarkerRange(marker_range);
+  if (range.IsNull())
+    return nil;
+  return base::SysUTF16ToNSString(range.GetText());
+}
+
+}  // namespace
+}  // namespace ui
+
 @interface AXPlatformNodeCocoa ()
 // Helper function for string attributes that don't require extra processing.
 - (NSString*)getStringAttribute:(ui::AXStringAttribute)attribute;
 // Returns AXValue, or nil if AXValue isn't an NSString.
 - (NSString*)getAXValueAsString;
+// Lazily creates a TextMarkerHelper and returns it.
+- (TextMarkerHelperMac*)textMarkerHelper;
 @end
 
 @implementation AXPlatformNodeCocoa {
   ui::AXPlatformNodeBase* node_;  // Weak. Retains us.
+  base::scoped_nsobject<TextMarkerHelperMac> textMarkerHelper_;
 }
 
 @synthesize node = node_;
 
 // A mapping of AX roles to native roles.
 + (NSString*)nativeRoleFromAXRole:(ui::AXRole)role {
   CR_DEFINE_STATIC_LOCAL(RoleMap, role_map, (BuildRoleMap()));
   RoleMap::iterator it = role_map.find(role);
   return it != role_map.end() ? it->second : NSAccessibilityUnknownRole;
 }
@@ skipping 18 matching lines @@
   }
   return self;
 }
 
 - (void)detach {
   if (!node_)
     return;
   NSAccessibilityPostNotification(
       self, NSAccessibilityUIElementDestroyedNotification);
   node_ = nil;
+
+  // Nothing retains |textMarkerHelper_|, so this should always dealloc.
+  textMarkerHelper_.reset();
 }
 
 - (NSRect)boundsInScreen {
   if (!node_)
     return NSZeroRect;
   return gfx::ScreenRectToNSRect(node_->GetBoundsInScreen());
 }
 
 - (NSString*)getStringAttribute:(ui::AXStringAttribute)attribute {
   std::string attributeValue;
   if (node_->GetStringAttribute(attribute, &attributeValue))
     return base::SysUTF8ToNSString(attributeValue);
   return nil;
 }
 
 - (NSString*)getAXValueAsString {
   id value = [self AXValue];
   return [value isKindOfClass:[NSString class]] ? value : nil;
 }
 
+- (TextMarkerHelperMac*)textMarkerHelper {
+  if (!textMarkerHelper_ && node_) {
+    DLOG(INFO) << "bail";
+    return nil;
+    textMarkerHelper_.reset([[TextMarkerHelperMac alloc]
+        initWithFactory:base::MakeUnique<ui::NodePositionFactory>(self)]);
+  }
+  return textMarkerHelper_;
+}
+
 // NSAccessibility informal protocol implementation.
 
 - (BOOL)accessibilityIsIgnored {
   return [[self AXRole] isEqualToString:NSAccessibilityUnknownRole] ||
          node_->GetData().HasState(ui::AX_STATE_INVISIBLE);
 }
 
 - (id)accessibilityHitTest:(NSPoint)point {
   for (AXPlatformNodeCocoa* child in [self AXChildren]) {
     if (![child accessibilityIsIgnored] &&
@@ skipping 79 matching lines @@
       [[NSMutableArray alloc] init]);
 
   [axAttributes addObjectsFromArray:kAllRoleAttributes];
 
   switch (node_->GetData().role) {
     case ui::AX_ROLE_TEXT_FIELD:
     case ui::AX_ROLE_STATIC_TEXT:
       [axAttributes addObject:kTextAttributes];
       if (!node_->GetData().HasState(ui::AX_STATE_PROTECTED))
         [axAttributes addObjectsFromArray:kUnprotectedTextAttributes];
+      [axAttributes
+          addObjectsFromArray:[TextMarkerHelperMac getSupportedAttributes]];
     // Fallthrough.
     case ui::AX_ROLE_CHECK_BOX:
     case ui::AX_ROLE_COMBO_BOX:
     case ui::AX_ROLE_MENU_ITEM_CHECK_BOX:
     case ui::AX_ROLE_MENU_ITEM_RADIO:
     case ui::AX_ROLE_RADIO_BUTTON:
     case ui::AX_ROLE_SEARCH_BOX:
     case ui::AX_ROLE_SLIDER:
     case ui::AX_ROLE_SLIDER_THUMB:
     case ui::AX_ROLE_TOGGLE_BUTTON:
       [axAttributes addObjectsFromArray:kValueAttributes];
       break;
     // TODO(tapted): Add additional attributes based on role.
     default:
       break;
   }
+  if (node_->GetData().role == ui::AX_ROLE_TEXT_FIELD) {
+    NSLog(@"%@ reports %@", [self AXValue], axAttributes.get());
+  }
   return axAttributes.autorelease();
 }
 
+- (NSArray*)accessibilityParameterizedAttributeNames {
+  static NSArray* const kEditableTextAttributes = [@[
+    NSAccessibilityLineForIndexParameterizedAttribute,
+    NSAccessibilityRangeForLineParameterizedAttribute,
+    NSAccessibilityStringForRangeParameterizedAttribute,
+    NSAccessibilityRangeForPositionParameterizedAttribute,
+    NSAccessibilityRangeForIndexParameterizedAttribute,
+    NSAccessibilityBoundsForRangeParameterizedAttribute,
+    NSAccessibilityRTFForRangeParameterizedAttribute,
+    NSAccessibilityAttributedStringForRangeParameterizedAttribute,
+    NSAccessibilityStyleRangeForIndexParameterizedAttribute,
+  ] retain];
+
+  base::scoped_nsobject<NSMutableArray> axAttributes(
+      [[NSMutableArray alloc] init]);
+  [axAttributes addObjectsFromArray:kEditableTextAttributes];
+  [axAttributes
+      addObjectsFromArray:[TextMarkerHelperMac
+                              getSupportedParameterizedAttributesExtended:YES]];
+  NSLog(@"PARAM!: %@ reports %@", [self AXValue], axAttributes.get());
+  return axAttributes.autorelease();
+}
+
 - (BOOL)accessibilityIsAttributeSettable:(NSString*)attributeName {
   if (node_->GetData().HasState(ui::AX_STATE_DISABLED))
     return NO;
 
   // Allow certain attributes to be written via an accessibility client. A
   // writable attribute will only appear as such if the accessibility element
   // has a value set for that attribute.
   if ([attributeName
           isEqualToString:NSAccessibilitySelectedChildrenAttribute] ||
       [attributeName
@@ skipping 57 matching lines @@
 
   if (data.action != ui::AX_ACTION_NONE)
     node_->GetDelegate()->AccessibilityPerformAction(data);
 
   // TODO(patricialor): Plumb through all the other writable attributes as
   // specified in accessibilityIsAttributeSettable.
 }
 
 - (id)accessibilityAttributeValue:(NSString*)attribute {
   SEL selector = NSSelectorFromString(attribute);
-  if ([self respondsToSelector:selector])
-    return [self performSelector:selector];
+  if ([TextMarkerHelperMac instancesRespondToSelector:selector]) {
+    DCHECK(![self respondsToSelector:selector]);
+    NSLog(@"supported: %@", attribute);
+    return [[self textMarkerHelper] performSelector:selector];
+  }
+  if ([self respondsToSelector:selector]) {
+    id result = [self performSelector:selector];
+    if (![attribute isEqualToString:@"AXRole"]) {
+      NSLog(@"Trying: %@ (%@) -> %@", attribute, [self AXValue], result);
+    }
+    return result;
+  }
+  NSLog(@"UNsupported: %@", attribute);
   return nil;
 }
 
+- (id)accessibilityAttributeValue:(NSString*)attribute
+                     forParameter:(id)parameter {
+  SEL selector = NSSelectorFromString([attribute stringByAppendingString:@":"]);
+  DCHECK(selector);
+  NSLog(@"Trying: %@ for %@", attribute, parameter);
+  if ([TextMarkerHelperMac instancesRespondToSelector:selector]) {
+    DCHECK(![self respondsToSelector:selector]);
+    return
+        [[self textMarkerHelper] performSelector:selector withObject:parameter];
+  }
+
+  if ([self respondsToSelector:selector])
+    return [self performSelector:selector withObject:parameter];
+
+  // TODO(tapted): Move these to TextMarkerHelper.
+  if ([attribute isEqualToString:@"AXStringForTextMarkerRange"])
+    return ui::GetTextForTextMarkerRange(parameter);
+
+  if ([attribute isEqualToString:@"AXAttributedStringForTextMarkerRange"]) {
+    if (NSString* str = ui::GetTextForTextMarkerRange(parameter)) {
+      base::scoped_nsobject<NSAttributedString> attrString(
+          [[NSAttributedString alloc] initWithString:str]);
+      return attrString.autorelease();
+    }
+  }
+
+  if ([attribute isEqualToString:@"AXLengthForTextMarkerRange"]) {
+    NSString* text = ui::GetTextForTextMarkerRange(parameter);
+    return [NSNumber numberWithInt:[text length]];
+  }
+  NSLog(@"Usupported: %@ for %@", attribute, parameter);
+  return nil;
+}
+
 // NSAccessibility attributes. Order them according to
 // NSAccessibilityConstants.h, or see https://crbug.com/678898.
 
 - (NSString*)AXRole {
   if (!node_)
     return nil;
   return [[self class] nativeRoleFromAXRole:node_->GetData().role];
 }
 
 - (NSString*)AXRoleDescription {
@@ skipping 19 matching lines @@
     default:
       break;
   }
   return [AXPlatformNodeCocoa nativeSubroleFromAXRole:role];
 }
 
 - (NSString*)AXHelp {
   return [self getStringAttribute:ui::AX_ATTR_DESCRIPTION];
 }
 
+- (NSString*)AXDescription {
+  return [self getStringAttribute:ui::AX_ATTR_DESCRIPTION];
+}
+
 - (id)AXValue {
   switch (node_->GetData().role) {
     case ui::AX_ROLE_TAB:
       return [self AXSelected];
     case ui::AX_ROLE_STATIC_TEXT:
       return [self AXTitle];
     default:
       break;
   }
   return [self getStringAttribute:ui::AX_ATTR_VALUE];
@@ skipping 67 matching lines @@
 - (NSValue*)AXSelectedTextRange {
   // Selection might not be supported. Return (NSRange){0,0} in that case.
   int start = 0, end = 0;
   node_->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START, &start);
   node_->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &end);
 
   // NSRange cannot represent the direction the text was selected in.
   return [NSValue valueWithRange:{std::min(start, end), abs(end - start)}];
 }
 
+- (NSArray*)AXSelectedTextRanges {
+  return @[ [self AXSelectedTextRange] ];
+}
+
 - (NSNumber*)AXNumberOfCharacters {
   return @([[self getAXValueAsString] length]);
 }
 
 - (NSValue*)AXVisibleCharacterRange {
   return [NSValue valueWithRange:{0, [[self getAXValueAsString] length]}];
 }
 
 - (NSNumber*)AXInsertionPointLineNumber {
   // Multiline is not supported on views.
   return @0;
 }
 
+- (id)AXStringForRange:(id)parameter {
+  DCHECK([parameter isKindOfClass:[NSValue class]]);
+  return [[self getAXValueAsString] substringWithRange:[parameter rangeValue]];
+}
+
+- (id)AXAttributedStringForRange:(id)parameter {
+  base::scoped_nsobject<NSAttributedString> attributedString(
+      [[NSAttributedString alloc]
+          initWithString:[self AXStringForRange:parameter]]);
+  return attributedString.autorelease();
+}
+
+- (id)AXRangeForLine:(id)parameter {
+  DCHECK([parameter isKindOfClass:[NSNumber class]]);
+  DCHECK_EQ(0, [parameter intValue]);
+  id r = [NSValue valueWithRange:{0, [[self getAXValueAsString] length]}];
+  NSLog(@"-> %@", r);
+  return r;
+}
+
+- (id)AXLineForIndex:(id)parameter {
+  DCHECK([parameter isKindOfClass:[NSNumber class]]);
+  return @0;
+}
+
+- (id)AXOwns {
+  return @[];
+}
+
+- (id)AXSharedTextUIElements {
+  return @[ self ];
+}
+
+- (id)AXSharedCharacterRange {
+  return [NSValue valueWithRange:{0, [[self getAXValueAsString] length]}];
+}
+
 @end
 
 namespace ui {
 
 // static
 AXPlatformNode* AXPlatformNode::Create(AXPlatformNodeDelegate* delegate) {
   AXPlatformNodeBase* node = new AXPlatformNodeMac();
   node->Init(delegate);
   return node;
 }
@@ skipping 40 matching lines @@
       break;
   }
   NotifyMacEvent(native_node_, event_type);
 }
 
 int AXPlatformNodeMac::GetIndexInParent() {
   // TODO(dmazzoni): implement this.  http://crbug.com/396137
   return -1;
 }
 
+AXPositionPointer NodePositionFactory::GetRoot() const {
+  if (![node_ node])
+    return nullptr;
+
+  return AXNodePosition::CreateTextPosition(1, [node_ node]->unique_id(), 0,
+                                            AX_TEXT_AFFINITY_DOWNSTREAM);
+}
+
+AXRangePointer NodePositionFactory::GetSelection() const {
+  return AXRangePointer(nullptr, nullptr);
+}
+
+AXPositionPointer NodePositionFactory::GetFromData(
+    const AXPositionData& data) const {
+  return AXNodePosition::CreateFromData(data);
+}
+
+id NodePositionFactory::GetAccessibilityObject(
+    const AXPositionData& data) const {
+  return node_;
+}
+
 }  // namespace ui