Upstream Chrome on iOS source code [9/11].

ios/chrome/browser/ui/util/label_link_controller.mm

+// Copyright 2015 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 "ios/chrome/browser/ui/util/label_link_controller.h"
+
+#include <map>
+#include <vector>
+
+#include "base/ios/ios_util.h"
+#include "base/ios/weak_nsobject.h"
+#include "base/logging.h"
+#include "base/mac/foundation_util.h"
+#include "base/mac/scoped_block.h"
+#import "base/mac/scoped_nsobject.h"
+#import "base/strings/sys_string_conversions.h"
+#include "ios/chrome/browser/ui/ui_util.h"
+#import "ios/chrome/browser/ui/util/label_observer.h"
+#import "ios/chrome/browser/ui/util/text_region_mapper.h"
+#import "ios/chrome/browser/ui/util/transparent_link_button.h"
+#import "net/base/mac/url_conversions.h"
+#include "url/gurl.h"
+
+#pragma mark - LinkLayout
+
+// Object encapsulating the range of a link and the frames corresponding with
+// that range.
+@interface LinkLayout : NSObject {
+  // Backing objects for properties of same name.
+  base::scoped_nsobject<NSArray> _frames;
+}
+
+// Designated initializer.
+- (instancetype)initWithRange:(NSRange)range NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+// The range passed on initialization.
+@property(nonatomic, readonly) NSRange range;
+
+// The frames calculated for |_range|.
+@property(nonatomic, retain) NSArray* frames;
+
+@end
+
+@implementation LinkLayout
+
+@synthesize range = _range;
+
+- (instancetype)initWithRange:(NSRange)range {
+  if ((self = [super init])) {
+    DCHECK_NE(range.location, static_cast<NSUInteger>(NSNotFound));
+    DCHECK_NE(range.length, 0U);
+    _range = range;
+  }
+  return self;
+}
+
+#pragma mark - Accessors
+
+- (void)setFrames:(NSArray*)frames {
+  _frames.reset([frames retain]);
+}
+
+- (NSArray*)frames {
+  return _frames.get();
+}
+
+@end
+
+#pragma mark - LabelLinkController
+
+@interface LabelLinkController ()
+// Private property exposed publically in testing interface.
+@property(nonatomic, assign) Class textMapperClass;
+
+// The original attributed text set on the label.  This may be different from
+// the label's |attributedText| property, as additional style attributes may be
+// introduced for links.
+@property(nonatomic, readonly) NSAttributedString* originalLabelText;
+
+// The array of TransparentLinkButtons inserted above the label.
+@property(nonatomic, readonly) NSArray* linkButtons;
+
+// Adds LabelObserverActions to the LabelObserver corresponding to |_label|.
+- (void)addLabelObserverActions;
+
+// Clears all defined links and any data associated with them. Update the
+// original attributed text from the controlled label.
+- (void)reset;
+
+// Handle a change to the label that changes the positioning of glyphs but not
+// any styling of those glyphs. Forces a recomputation of the tap regions, and
+// recreates any tap buttons.
+- (void)labelLayoutInvalidated;
+
+// Handle a change to the label that changes the glyph style. This forces all of
+// the link-specific styling applied by this class to be regenerated (which
+// itself will again re-trigger this method), and because any kind of style
+// change may alter the position of glyphs, this forces a layout invalidation.
+- (void)labelStyleInvalidated;
+
+// Updates the attributed string content of the controlled label to
+// have the designated link colors and styles.
+// No-op if no links are defined.
+- (void)updateStyles;
+
+// If the controlled label's bounds have changed from the last time tap rects
+// were updated, determine which regions in the label should be tappable.
+- (void)updateTapRects;
+
+// Creates a new text mapper instance with the current label bounds and
+// attributed text.
+- (void)resetTextMapper;
+
+// Clear any tap buttons that have been created, removing them from their
+// superview if necessary.
+- (void)clearTapButtons;
+
+// Updates the tap buttons as detailed below. This method is called every time
+// tap rects are updated, as well as every time |_label|'s superview changes.
+// If there are no tap buttons defined, but there are known tap rects, and
+// |_label| has a superview, then tap buttons are created and added to that
+// view.
+// If there are tap buttons, and |_label| has no superview, then the tap buttons
+// are cleared.
+// If there are tap buttons, but they are not subviews of |_label|'s superview
+// (if _label's superview has changed since the buttons were created), then
+// the tap buttons are migrated into the new superview.
+- (void)updateTapButtons;
+
+@end
+
+@implementation LabelLinkController {
+  // Ivars immutable for the lifetime of the object.
+  base::mac::ScopedBlock<ProceduralBlockWithURL> _action;
+  base::WeakNSObject<UILabel> _label;  // weak
+  base::scoped_nsobject<UITapGestureRecognizer> _linkTapRecognizer;
+
+  // Ivas backing properties.
+  base::scoped_nsobject<UIColor> _linkColor;
+  base::scoped_nsobject<UIFont> _linkFont;
+
+  // Ivars that reset when label text changes.
+  base::scoped_nsobject<NSMutableDictionary> _layoutsForURLs;
+  base::scoped_nsobject<NSAttributedString> _originalLabelText;
+  CGRect _lastLabelFrame;
+
+  // Ivars that reset when text or bounds change.
+  base::scoped_nsprotocol<id<TextRegionMapper>> _textMapper;
+
+  // Internal tracking.
+  BOOL _justUpdatedStyles;
+  base::scoped_nsobject<NSMutableArray> _linkButtons;
+}
+
+@synthesize showTapAreas = _showTapAreas;
+@synthesize textMapperClass = _textMapperClass;
+@synthesize linkUnderlineStyle = _linkUnderlineStyle;
+
+- (instancetype)initWithLabel:(UILabel*)label
+                       action:(ProceduralBlockWithURL)action {
+  if ((self = [super init])) {
+    DCHECK(label);
+    _label.reset(label);
+    _action.reset(action, base::scoped_policy::RETAIN);
+    _linkUnderlineStyle = NSUnderlineStyleNone;
+    [self reset];
+
+    [self addLabelObserverActions];
+
+    self.textMapperClass = [CoreTextRegionMapper class];
+    _linkButtons.reset([[NSMutableArray alloc] init]);
+  }
+  return self;
+}
+
+- (NSAttributedString*)originalLabelText {
+  return _originalLabelText.get();
+}
+
+- (NSArray*)linkButtons {
+  return _linkButtons.get();
+}
+
+- (void)addLabelObserverActions {
+  LabelObserver* observer = [LabelObserver observerForLabel:_label];
+  base::WeakNSObject<LabelLinkController> weakSelf(self);
+  [observer addStyleChangedAction:^(UILabel* label) {
+    // One of the style properties has been changed, which will silently
+    // update the label's attributedText.
+    if (!weakSelf)
+      return;
+    base::scoped_nsobject<LabelLinkController> strongSelf([weakSelf retain]);
+    [strongSelf labelStyleInvalidated];
+  }];
+  [observer addTextChangedAction:^(UILabel* label) {
+    if (!weakSelf)
+      return;
+    base::scoped_nsobject<LabelLinkController> strongSelf([weakSelf retain]);
+    NSString* originalText = [[strongSelf originalLabelText] string];
+    if ([label.text isEqualToString:originalText]) {
+      // The actual text of the label didn't change, so this was a change to
+      // the string attributes only.
+      [strongSelf labelStyleInvalidated];
+    } else {
+      // The label text has changed, so start everything from scratch.
+      [strongSelf reset];
+    }
+  }];
+  [observer addLayoutChangedAction:^(UILabel* label) {
+    if (!weakSelf)
+      return;
+    base::scoped_nsobject<LabelLinkController> strongSelf([weakSelf retain]);
+    [strongSelf labelLayoutInvalidated];
+    NSArray* linkButtons = [strongSelf linkButtons];
+    // If this layout change corresponds to |label|'s moving to a new superview,
+    // update the tap buttons so that they are inserted above |label| in the new
+    // hierarchy.
+    if (linkButtons.count && label.superview != [linkButtons[0] superview])
+      [strongSelf updateTapButtons];
+  }];
+}
+
+- (void)dealloc {
+  [self clearTapButtons];
+  [super dealloc];
+}
+
+- (void)addLinkWithRange:(NSRange)range url:(GURL)url {
+  DCHECK(url.is_valid());
+  if (!_layoutsForURLs)
+    _layoutsForURLs.reset([[NSMutableDictionary alloc] init]);
+  NSURL* key = net::NSURLWithGURL(url);
+  base::scoped_nsobject<LinkLayout> layout(
+      [[LinkLayout alloc] initWithRange:range]);
+  [_layoutsForURLs setObject:layout forKey:key];
+  [self updateStyles];
+}
+
+- (UIColor*)linkColor {
+  return _linkColor.get();
+}
+
+- (void)setLinkColor:(UIColor*)linkColor {
+  _linkColor.reset([linkColor copy]);
+  [self updateStyles];
+}
+
+- (void)setLinkUnderlineStyle:(NSUnderlineStyle)underlineStyle {
+  _linkUnderlineStyle = underlineStyle;
+  [self updateStyles];
+}
+
+- (UIFont*)linkFont {
+  return _linkFont.get();
+}
+
+- (void)setLinkFont:(UIFont*)linkFont {
+  _linkFont.reset([linkFont retain]);
+  [self updateStyles];
+}
+
+- (void)setShowTapAreas:(BOOL)showTapAreas {
+#ifndef NDEBUG
+  for (TransparentLinkButton* button in _linkButtons.get()) {
+    button.debug = showTapAreas;
+  }
+#endif  // NDEBUG
+  _showTapAreas = showTapAreas;
+}
+
+#pragma mark - internal methods
+
+- (void)reset {
+  _originalLabelText.reset([[_label attributedText] copy]);
+  _textMapper.reset();
+  _lastLabelFrame = CGRectZero;
+  _layoutsForURLs.reset();
+}
+
+- (void)labelLayoutInvalidated {
+  _textMapper.reset();
+  [self updateTapRects];
+}
+
+- (void)labelStyleInvalidated {
+  // If the style invalidation was triggered by this class updating link styles,
+  // then the original label text is still correct, but the tap rects still need
+  // to be updated. Otherwise, update the original label text, and then update
+  // styles. This will set |_justUpdatedStyles| and trigger another call to
+  // this method via KVO.
+  if (_justUpdatedStyles) {
+    // TODO(crbug.com/664648): Remove _justUpdatedStyles due to bug that
+    // prevents proper style updates after successive label format changes.
+    _justUpdatedStyles = NO;
+  } else if (![_originalLabelText isEqual:[_label attributedText]]) {
+    _originalLabelText.reset([[_label attributedText] copy]);
+    [self updateStyles];
+  }
+  _lastLabelFrame = CGRectZero;
+  [self labelLayoutInvalidated];
+}
+
+- (void)updateStyles {
+  if (![_layoutsForURLs count])
+    return;
+
+  __block base::scoped_nsobject<NSMutableAttributedString> labelText(
+      [_originalLabelText mutableCopy]);
+  [_layoutsForURLs enumerateKeysAndObjectsUsingBlock:^(
+                       NSURL* key, LinkLayout* layout, BOOL* stop) {
+    if (_linkColor) {
+      [labelText addAttribute:NSForegroundColorAttributeName
+                        value:_linkColor
+                        range:layout.range];
+    }
+    if (_linkUnderlineStyle != NSUnderlineStyleNone) {
+      [labelText addAttribute:NSUnderlineStyleAttributeName
+                        value:@(_linkUnderlineStyle)
+                        range:layout.range];
+    }
+    if (_linkFont) {
+      [labelText addAttribute:NSFontAttributeName
+                        value:_linkFont
+                        range:layout.range];
+    }
+  }];
+  _justUpdatedStyles = YES;
+  [_label setAttributedText:labelText];
+  _textMapper.reset();
+}
+
+- (void)updateTapRects {
+  // Don't update if the label hasn't changed size or position.
+  if (CGRectEqualToRect([_label frame], _lastLabelFrame))
+    return;
+  // Don't update if there are no links.
+  if (![_layoutsForURLs count])
+    return;
+
+  _lastLabelFrame = [_label frame];
+  [self clearTapButtons];
+
+  // If the label bounds are zero in either dimension, no rects are possible.
+  if (0.0 == _lastLabelFrame.size.width || 0.0 == _lastLabelFrame.size.height)
+    return;
+
+  if (!_textMapper)
+    [self resetTextMapper];
+
+  for (LinkLayout* layout in [_layoutsForURLs allValues]) {
+    base::scoped_nsobject<NSMutableArray> frames([[NSMutableArray alloc] init]);
+    NSArray* rects = [_textMapper rectsForRange:layout.range];
+    for (NSUInteger rectIdx = 0; rectIdx < [rects count]; ++rectIdx) {
+      CGRect frame = [rects[rectIdx] CGRectValue];
+      frame = [[_label superview] convertRect:frame fromView:_label];
+      [frames addObject:[NSValue valueWithCGRect:frame]];
+    }
+    layout.frames = frames;
+  }
+  [self updateTapButtons];
+}
+
+- (void)resetTextMapper {
+  DCHECK([self.textMapperClass conformsToProtocol:@protocol(TextRegionMapper)]);
+  _textMapper.reset([[self.textMapperClass alloc]
+      initWithAttributedString:[_label attributedText]
+                        bounds:[_label bounds]]);
+}
+
+- (void)clearTapButtons {
+  for (TransparentLinkButton* button in _linkButtons.get()) {
+    [button removeFromSuperview];
+  }
+  [_linkButtons removeAllObjects];
+}
+
+- (void)updateTapButtons {
+  // If the label has no superview, clear any existing buttons.
+  if (![_label superview]) {
+    [self clearTapButtons];
+    return;
+  } else if ([_linkButtons count]) {
+    // If the buttons are currently in some view other than the label's
+    // superview, repatriate them.
+    if (base::mac::ObjCCast<TransparentLinkButton>(_linkButtons[0]).superview !=
+        [_label superview]) {
+      for (TransparentLinkButton* button in _linkButtons.get()) {
+        CGRect newFrame =
+            [[_label superview] convertRect:button.frame fromView:button];
+        [[_label superview] insertSubview:button aboveSubview:_label];
+        button.frame = newFrame;
+      }
+    }
+  }
+  // If there are no buttons, make some and put them in the label's superview.
+  if (![_linkButtons count] && _layoutsForURLs) {
+    [_layoutsForURLs enumerateKeysAndObjectsUsingBlock:^(
+                         NSURL* key, LinkLayout* layout, BOOL* stop) {
+      GURL URL = net::GURLWithNSURL(key);
+      NSString* accessibilityLabel =
+          [[_label text] substringWithRange:layout.range];
+      NSArray* buttons =
+          [TransparentLinkButton buttonsForLinkFrames:layout.frames
+                                                  URL:URL
+                                   accessibilityLabel:accessibilityLabel];
+      for (TransparentLinkButton* button in buttons) {
+#ifndef NDEBUG
+        button.debug = self.showTapAreas;
+#endif  // NDEBUG
+        [button addTarget:self
+                      action:@selector(linkButtonTapped:)
+            forControlEvents:UIControlEventTouchUpInside];
+        [[_label superview] insertSubview:button aboveSubview:_label];
+        [_linkButtons addObject:button];
+      }
+    }];
+  }
+}
+
+#pragma mark - Tap Handlers
+
+- (void)linkButtonTapped:(id)sender {
+  TransparentLinkButton* button =
+      base::mac::ObjCCast<TransparentLinkButton>(sender);
+  _action.get()(button.URL);
+}
+
+#pragma mark - Test facilitators
+
+- (NSArray*)tapRectsForURL:(GURL)url {
+  NSURL* key = net::NSURLWithGURL(url);
+  LinkLayout* layout = [_layoutsForURLs objectForKey:key];
+  return layout.frames;
+}
+
+- (void)tapLabelAtPoint:(CGPoint)point {
+  [_layoutsForURLs enumerateKeysAndObjectsUsingBlock:^(
+                       NSURL* key, LinkLayout* layout, BOOL* stop) {
+    for (NSValue* frameValue in layout.frames) {
+      CGRect frame = [frameValue CGRectValue];
+      if (CGRectContainsPoint(frame, point)) {
+        _action.get()(net::GURLWithNSURL(key));
+        *stop = YES;
+        break;
+      }
+    }
+  }];
+}
+
+@end