// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#import "ios/web/web_state/ui/crw_web_view_scroll_view_proxy+internal.h"
#import <objc/runtime.h>
#import <memory>
#import "base/apple/foundation_util.h"
#import "base/auto_reset.h"
#import "base/ios/crb_protocol_observers.h"
#import "base/strings/sys_string_conversions.h"
#import "ios/web/common/features.h"
#import "ios/web/web_state/ui/crw_web_view_scroll_view_delegate_proxy.h"
// *Address of* this variable is used as a marker to specify that it matches any
// context.
static int gAnyContext = 0;
// A wrapper of a key-value observer. When an instance of
// CRWKeyValueObserverForwarder receives a KVO callback, it forwards the
// callback to `wrappedObserver`, but replacing the object parameter with the
// `object` given in its initializer.
//
// This is useful when creating a proxy class of an object and forwarding KVO
// against the proxy object to the underlying object, but making the KVO
// callback still look like a callback from the proxy object.
@interface CRWKeyValueObserverForwarder : NSObject
@property(nonatomic, weak) id wrappedObserver;
@property(nonatomic, weak) id object;
@property(nonatomic) NSKeyValueObservingOptions options;
@property(nonatomic) void* context;
- (instancetype)initWithWrappedObserver:(id)wrappedObserver
object:(id)object
options:(NSKeyValueObservingOptions)options
context:(void*)context
NS_DESIGNATED_INITIALIZER;
- (instancetype)init NS_UNAVAILABLE;
@end
@implementation CRWKeyValueObserverForwarder
- (instancetype)initWithWrappedObserver:(id)wrappedObserver
object:(id)object
options:(NSKeyValueObservingOptions)options
context:(void*)context {
self = [super init];
if (self) {
_wrappedObserver = wrappedObserver;
_object = object;
_options = options;
_context = context;
}
return self;
}
- (void)observeValueForKeyPath:(NSString*)keyPath
ofObject:(id)object
change:(NSDictionary*)change
context:(void*)context {
[self.wrappedObserver observeValueForKeyPath:keyPath
ofObject:self.object
change:change
context:context];
}
@end
@interface CRWWebViewScrollViewProxy ()
// A delegate object of the UIScrollView managed by this class.
@property(nonatomic, strong, readonly)
CRWWebViewScrollViewDelegateProxy* delegateProxy;
@property(nonatomic, strong)
CRBProtocolObservers<CRWWebViewScrollViewProxyObserver>* observers;
@property(nonatomic, strong) UIScrollView* underlyingScrollView;
// This exists for compatibility with UIScrollView (see -asUIScrollView).
@property(nonatomic, weak) id<UIScrollViewDelegate> delegate;
// Wrappers of key-value observers against this instance, keyed by:
// - the key path (the outer dictionary)
// - NSValue representation of an unretained pointer to the observer (the
// inner dictionary).
//
// This dictionary must hold an *unretained* pointer to the observer, neither a
// strong or weak pointer.
// - An object should not retain its key-value observer. So it must not be a
// strong pointer.
// - The dictionary may be accessed during -dealloc of an observer. This is
// quite possible because it is common that an observer calls
// -removeObserver:forKeyPath: during its -dealloc, and this dictionary is
// accessed in -removeObserver:forKeyPath:. And a weak pointer to an object
// is not available during its -dealloc.
//
// And holding NSValue wrapping the pointer is the only way to use an unretained
// pointer as a key of a dictionary. NSMapTable supports using a weak pointer
// for its keys, but not an unretained pointer.
//
// Use of an unretained pointer here is safe because it is never dereferenced,
// and the observer must call -removeObserver:forKeyPath: before it is
// deallocated.
@property(nonatomic, strong) NSMutableDictionary<
NSString*,
NSMutableDictionary<NSValue*,
NSMutableArray<CRWKeyValueObserverForwarder*>*>*>*
keyValueObserverForwarders;
// Returns the key paths that need to be observed for UIScrollView.
+ (NSArray*)scrollViewObserverKeyPaths;
// Adds and removes key-value observers for `scrollView` needed by `proxy`.
+ (void)startObservingScrollView:(UIScrollView*)scrollView
proxy:(CRWWebViewScrollViewProxy*)proxy;
+ (void)stopObservingScrollView:(UIScrollView*)scrollView
proxy:(CRWWebViewScrollViewProxy*)proxy;
@end
// Note: An instance of this class must be safely casted to UIScrollView. See
// -asUIScrollView. To make it happen:
// - When this class defines a method with the same selector as in a method of
// UIScrollView (or its ancestor classes), its API and the behavior should
// be consistent with the UIScrollView one's.
// - Calls to UIScrollView methods not implemented in this class are forwarded
// to the underlying UIScrollView by -methodSignatureForSelector: and
// -forwardInvocation:.
@implementation CRWWebViewScrollViewProxy
- (instancetype)init {
self = [super init];
if (self) {
Protocol* protocol = @protocol(CRWWebViewScrollViewProxyObserver);
_observers =
static_cast<CRBProtocolObservers<CRWWebViewScrollViewProxyObserver>*>(
[CRBProtocolObservers observersWithProtocol:protocol]);
_delegateProxy = [[CRWWebViewScrollViewDelegateProxy alloc]
initWithScrollViewProxy:self];
_keyValueObserverForwarders = [[NSMutableDictionary alloc] init];
// Assign a placeholder UIScrollView until the actual underlying scroll view
// is set. This must be a real UIScrollView, not nil, so that:
// - The proxy preserves the values of properties assigned before the
// actual scroll view is set. These properties will then be inherited to
// the actual scroll view in -setScrollView:.
// - The proxy returns the actual default value of the property before the
// actual scroll view is set, even when the default value is non-zero
// e.g., scrollsToTop.
// - The proxy uses the actual implementation of methods defined in
// third-party categories of UIScrollView.
//
// Note that this proxy must support all methods/properties of UIScrollView,
// including those defined in third-party categories, because it provides
// -asUIScrollView method.
_underlyingScrollView = [[UIScrollView alloc] init];
// There are a few properties where the default WKWebView.scrollView has
// different values from a base UIScrollView. As _underlyingScrollView
// starts out as a base UIScrollView, the property preservation code will
// copy over these incorrect values and overwrite the default
// WKWebView.scrollView values for those properties. Instead, set those
// values to their WebKit defaults.
_underlyingScrollView.alwaysBounceVertical = YES;
_underlyingScrollView.directionalLockEnabled = YES;
[self.class startObservingScrollView:_underlyingScrollView proxy:self];
}
return self;
}
- (void)dealloc {
[self.class stopObservingScrollView:self.underlyingScrollView proxy:self];
}
- (void)addObserver:(id<CRWWebViewScrollViewProxyObserver>)observer {
[_observers addObserver:observer];
}
- (void)removeObserver:(id<CRWWebViewScrollViewProxyObserver>)observer {
[_observers removeObserver:observer];
}
- (void)setScrollView:(UIScrollView*)scrollView {
if (self.underlyingScrollView == scrollView)
return;
// Use a placeholder UIScrollView instead when nil is given. See the comment
// in -init why this is necessary.
if (!scrollView) {
scrollView = [[UIScrollView alloc] init];
}
// Clean up the delegate/observers of the old scroll view.
[self.underlyingScrollView setDelegate:nil];
[self.class stopObservingScrollView:self.underlyingScrollView proxy:self];
// Set up the delegate/observers of the new scroll view.
DCHECK(!scrollView.delegate);
scrollView.delegate = self.delegateProxy;
[self.class startObservingScrollView:scrollView proxy:self];
[self preservePropertiesFromOldScrollView:self.underlyingScrollView
toNewScrollView:scrollView];
self.underlyingScrollView = scrollView;
[_observers webViewScrollViewProxyDidSetScrollView:self];
}
// Preserves properties of the underlying scroll view when it changes from
// `oldScrollView` to `newScrollView`.
//
// This is necessary to avoid losing properties set against the proxy when the
// underlying scroll view is reset.
- (void)preservePropertiesFromOldScrollView:(UIScrollView*)oldScrollView
toNewScrollView:(UIScrollView*)newScrollView {
// This method should preserve all properties of UIScrollView and its
// ancestor classes (not limited to properties explicitly declared in
// CRWWebViewScrollViewProxy) which:
// - is a readwrite property
// - AND is supposed to be modified directly, considering it's a scroll
// view of a web view. e.g., `frame` and `subviews` do not meet this
// condition because they are managed by the web view. `backgroundColor`
// is also managed by WKWebView to match the page's background color, and
// should not be set directly (see crbug.com/1078790).
//
// Properties not explicitly declared in CRWWebViewScrollViewProxy can still
// be accessed via -asUIScrollView, so they should be preserved as well.
// UIScrollView properties.
if (base::FeatureList::IsEnabled(
web::features::kScrollViewProxyScrollEnabledWorkaround)) {
if (newScrollView.scrollEnabled != oldScrollView.scrollEnabled) {
// Don't update scrollEnabled if it is the same value as it creates issues
// with clobbering state in WebKit, since the getter and setter in WebKit
// are not symmetric. The setter sets state about whether the WKWebView
// embedder wants to disable scrolling, while the getter and used value
// also account for whether the main-frame is scrollable (e.g., due to the
// size of its content relative to the viewport). See crbug.com/1375837.
newScrollView.scrollEnabled = oldScrollView.scrollEnabled;
}
} else {
newScrollView.scrollEnabled = oldScrollView.scrollEnabled;
}
newScrollView.directionalLockEnabled = oldScrollView.directionalLockEnabled;
newScrollView.pagingEnabled = oldScrollView.pagingEnabled;
newScrollView.scrollsToTop = oldScrollView.scrollsToTop;
newScrollView.bounces = oldScrollView.bounces;
newScrollView.alwaysBounceVertical = oldScrollView.alwaysBounceVertical;
newScrollView.alwaysBounceHorizontal = oldScrollView.alwaysBounceHorizontal;
newScrollView.showsHorizontalScrollIndicator =
oldScrollView.showsHorizontalScrollIndicator;
newScrollView.showsVerticalScrollIndicator =
oldScrollView.showsVerticalScrollIndicator;
newScrollView.canCancelContentTouches = oldScrollView.canCancelContentTouches;
newScrollView.delaysContentTouches = oldScrollView.delaysContentTouches;
newScrollView.keyboardDismissMode = oldScrollView.keyboardDismissMode;
newScrollView.indexDisplayMode = oldScrollView.indexDisplayMode;
newScrollView.indicatorStyle = oldScrollView.indicatorStyle;
// UIView properties.
newScrollView.hidden = oldScrollView.hidden;
newScrollView.alpha = oldScrollView.alpha;
newScrollView.opaque = oldScrollView.opaque;
newScrollView.tintColor = oldScrollView.tintColor;
newScrollView.tintAdjustmentMode = oldScrollView.tintAdjustmentMode;
newScrollView.clearsContextBeforeDrawing =
oldScrollView.clearsContextBeforeDrawing;
newScrollView.maskView = oldScrollView.maskView;
newScrollView.userInteractionEnabled = oldScrollView.userInteractionEnabled;
newScrollView.multipleTouchEnabled = oldScrollView.multipleTouchEnabled;
newScrollView.exclusiveTouch = oldScrollView.exclusiveTouch;
if (newScrollView.clipsToBounds != oldScrollView.clipsToBounds) {
newScrollView.clipsToBounds = oldScrollView.clipsToBounds;
}
if (newScrollView.contentInsetAdjustmentBehavior !=
oldScrollView.contentInsetAdjustmentBehavior) {
newScrollView.contentInsetAdjustmentBehavior =
oldScrollView.contentInsetAdjustmentBehavior;
}
}
- (BOOL)clipsToBounds {
return self.underlyingScrollView.clipsToBounds;
}
- (void)setClipsToBounds:(BOOL)clipsToBounds {
self.underlyingScrollView.clipsToBounds = clipsToBounds;
}
- (UIScrollViewContentInsetAdjustmentBehavior)contentInsetAdjustmentBehavior {
return [self.underlyingScrollView contentInsetAdjustmentBehavior];
}
- (void)setContentInsetAdjustmentBehavior:
(UIScrollViewContentInsetAdjustmentBehavior)contentInsetAdjustmentBehavior {
[self.underlyingScrollView
setContentInsetAdjustmentBehavior:contentInsetAdjustmentBehavior];
}
- (NSArray<__kindof UIView*>*)subviews {
return [self.underlyingScrollView subviews];
}
#pragma mark -
+ (NSArray*)scrollViewObserverKeyPaths {
if (base::FeatureList::IsEnabled(web::features::kSmoothScrollingDefault)) {
return @[ @"frame", @"contentSize", @"contentInset" ];
} else {
return @[ @"contentSize" ];
}
}
+ (void)startObservingScrollView:(UIScrollView*)scrollView
proxy:(CRWWebViewScrollViewProxy*)proxy {
// Add observations by `proxy`.
for (NSString* keyPath in [proxy.class scrollViewObserverKeyPaths]) {
[scrollView
addObserver:proxy
forKeyPath:keyPath
options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
context:nil];
}
// Restore observers which were added to the past underlying scroll views.
for (NSString* keyPath in proxy.keyValueObserverForwarders) {
NSMutableDictionary<NSValue*,
NSMutableArray<CRWKeyValueObserverForwarder*>*>* map =
proxy.keyValueObserverForwarders[keyPath];
for (NSValue* observerValue in map) {
for (CRWKeyValueObserverForwarder* observerForwarder in
map[observerValue]) {
[scrollView addObserver:observerForwarder
forKeyPath:keyPath
options:observerForwarder.options
context:observerForwarder.context];
}
}
}
}
+ (void)stopObservingScrollView:(UIScrollView*)scrollView
proxy:(CRWWebViewScrollViewProxy*)proxy {
// Remove observations by `self`.
for (NSString* keyPath in [proxy.class scrollViewObserverKeyPaths]) {
[scrollView removeObserver:proxy forKeyPath:keyPath];
}
// Remove observations added externally.
for (NSString* keyPath in proxy.keyValueObserverForwarders) {
NSMutableDictionary<NSValue*,
NSMutableArray<CRWKeyValueObserverForwarder*>*>* map =
proxy.keyValueObserverForwarders[keyPath];
for (NSValue* observerValue in map) {
for (CRWKeyValueObserverForwarder* observerForwarder in
map[observerValue]) {
[scrollView removeObserver:observerForwarder
forKeyPath:keyPath
context:observerForwarder.context];
}
}
}
}
- (void)observeValueForKeyPath:(NSString*)keyPath
ofObject:(id)object
change:(NSDictionary*)change
context:(void*)context {
DCHECK_EQ(object, self.underlyingScrollView);
if (base::FeatureList::IsEnabled(web::features::kSmoothScrollingDefault)) {
if ([keyPath isEqualToString:@"frame"]) {
[_observers webViewScrollViewFrameDidChange:self];
}
if ([keyPath isEqualToString:@"contentInset"]) {
[_observers webViewScrollViewDidResetContentInset:self];
}
}
if ([keyPath isEqualToString:@"contentSize"]) {
if (!base::FeatureList::IsEnabled(web::features::kSmoothScrollingDefault)) {
NSValue* oldValue =
base::apple::ObjCCast<NSValue>(change[NSKeyValueChangeOldKey]);
NSValue* newValue =
base::apple::ObjCCast<NSValue>(change[NSKeyValueChangeNewKey]);
// If the value is unchanged -- if the old and new values are equal --
// then return without notifying observers.
if (oldValue && newValue && [newValue isEqualToValue:oldValue]) {
return;
}
}
[_observers webViewScrollViewDidResetContentSize:self];
}
}
- (UIScrollView*)asUIScrollView {
// See the comment of @implementation of this class for why this should be
// safe.
return (UIScrollView*)self;
}
#pragma mark - Forwards unimplemented UIScrollView methods
- (NSMethodSignature*)methodSignatureForSelector:(SEL)sel {
// Called when this proxy is accessed through -asUIScrollView and the method
// is not implemented in this class.
return [self.underlyingScrollView methodSignatureForSelector:sel];
}
- (void)forwardInvocation:(NSInvocation*)invocation {
// Called when this proxy is accessed through -asUIScrollView and the method
// is not implemented in this class. Forwards the invocation to the undelrying
// scroll view.
[invocation invokeWithTarget:self.underlyingScrollView];
}
#pragma mark - NSObject
- (BOOL)isKindOfClass:(Class)aClass {
// Pretend self to be a kind of UIScrollView.
return
[UIScrollView isSubclassOfClass:aClass] || [super isKindOfClass:aClass];
}
- (BOOL)respondsToSelector:(SEL)aSelector {
// Respond to both of UIScrollView methods and its own methods.
return [UIScrollView instancesRespondToSelector:aSelector] ||
[super respondsToSelector:aSelector];
}
#pragma mark - KVO
- (void)addObserver:(NSObject*)observer
forKeyPath:(NSString*)keyPath
options:(NSKeyValueObservingOptions)options
context:(nullable void*)context {
// KVO against CRWWebViewScrollViewProxy works as KVO against the underlying
// scroll view, except that `object` parameter of the notification points to
// CRWWebViewScrollViewProxy, not the undelying scroll view. This is achieved
// by CRWKeyValueObserverForwarder.
NSMutableDictionary<NSValue*, NSMutableArray<CRWKeyValueObserverForwarder*>*>*
map = _keyValueObserverForwarders[keyPath];
if (!map) {
map = [[NSMutableDictionary alloc] init];
_keyValueObserverForwarders[keyPath] = map;
}
// See the comment of the definition of _keyValueObserverForwarders for why
// NSValue with an unretained pointer is used here.
NSValue* observerValue = [NSValue valueWithNonretainedObject:observer];
NSMutableArray<CRWKeyValueObserverForwarder*>* observerForwarders =
map[observerValue];
if (!observerForwarders) {
observerForwarders = [[NSMutableArray alloc] init];
map[observerValue] = observerForwarders;
}
CRWKeyValueObserverForwarder* observerForwarder =
[[CRWKeyValueObserverForwarder alloc] initWithWrappedObserver:observer
object:self
options:options
context:context];
[observerForwarders addObject:observerForwarder];
[self.underlyingScrollView addObserver:observerForwarder
forKeyPath:keyPath
options:options
context:context];
}
- (void)removeObserver:(NSObject*)observer forKeyPath:(NSString*)keyPath {
[self removeObserver:observer forKeyPath:keyPath context:&gAnyContext];
}
- (void)removeObserver:(NSObject*)observer
forKeyPath:(NSString*)keyPath
context:(void*)context {
NSMutableDictionary<NSValue*, NSMutableArray<CRWKeyValueObserverForwarder*>*>*
map = _keyValueObserverForwarders[keyPath];
// See the comment of the definition of _keyValueObserverForwarders for why
// NSValue with an unretained pointer is used here.
NSValue* observerValue = [NSValue valueWithNonretainedObject:observer];
NSMutableArray<CRWKeyValueObserverForwarder*>* observerForwarders =
map[observerValue];
// It is technically allowed to call -addObserver:forKeypath:options:context:
// multiple times with the same `observer` and same `keyPath`. And
// -removeObserver:forKeyPath:context: (and -removeObserver:forKeyPath:)
// removes the *last* observation matching the condition. This matches the
// (undocumented) behavior of the built-in KVO.
NSInteger i = static_cast<NSInteger>(observerForwarders.count) - 1;
for (; i >= 0; --i) {
if (context == &gAnyContext || observerForwarders[i].context == context) {
break;
}
}
// DCHECK on an attempt to remove an observer which is not registered. This
// behavior is inconsistent with the behavior of this method in NSObject
// (which throws an exception in this case). But Chromium code is not allowed
// to throw exceptions.
DCHECK_GE(i, 0) << base::SysNSStringToUTF8(
context == &gAnyContext
? [NSString
stringWithFormat:
@"Cannot remove an observer %@ for the key path \"%@\" "
@"from %@ because it is not registered as an observer.",
observer, keyPath, self]
: [NSString
stringWithFormat:
@"Cannot remove an observer %@ for the key path \"%@\" "
@"with context %p from %@ because it is not registered as "
@"an observer.",
observer, keyPath, context, self]);
[self.underlyingScrollView removeObserver:observerForwarders[i]
forKeyPath:keyPath];
[observerForwarders removeObjectAtIndex:i];
}
@end
Codebase Browser
chromium