Moves overscroll code out of the ios_internal namespace.

ios/chrome/browser/ui/overscroll_actions/overscroll_actions_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/overscroll_actions/overscroll_actions_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <algorithm>
 #include "base/logging.h"
@@ skipping 76 matching lines @@
 CGFloat Clamp(CGFloat value, CGFloat min, CGFloat max) {
   DCHECK(min < max);
   if (value < min)
     return min;
   if (value > max)
     return max;
   return value;
 }
 }  // namespace
 
-namespace ios_internal {
-NSString* const kOverscollActionsWillStart = @"OverscollActionsWillStart";
-NSString* const kOverscollActionsDidEnd = @"OverscollActionsDidStop";
-}  // namespace ios_internal
+NSString* const kOverscrollActionsWillStart = @"OverscrollActionsWillStart";
+NSString* const kOverscrollActionsDidEnd = @"OverscrollActionsDidStop";
 
 // This protocol describes the subset of methods used between the
 // CRWWebViewScrollViewProxy and the UIWebView.
 @protocol OverscrollActionsScrollView<NSObject>
 
 @property(nonatomic, assign) UIEdgeInsets contentInset;
 @property(nonatomic, assign) CGPoint contentOffset;
 @property(nonatomic, assign) UIEdgeInsets scrollIndicatorInsets;
 @property(nonatomic, readonly) UIPanGestureRecognizer* panGestureRecognizer;
 @property(nonatomic, readonly) BOOL isZooming;
@@ skipping 65 matching lines @@
 @property(nonatomic, readonly) CGFloat initialContentInset;
 // Initial top inset for the header.
 // This property is set from the delegate headerInset and cached on first
 // call. The cached value is reset when the webview proxy is set.
 @property(nonatomic, readonly) CGFloat initialHeaderInset;
 // Initial height of the header view.
 // This property is set from the delegate headerHeight and cached on first
 // call. The cached value is reset when the webview proxy is set.
 @property(nonatomic, readonly) CGFloat initialHeaderHeight;
 // Redefined to be read-write.
-@property(nonatomic, assign, readwrite)
-    ios_internal::OverscrollState overscrollState;
+@property(nonatomic, assign, readwrite) OverscrollState overscrollState;
 // Point where the horizontal gesture started when the state of the
 // overscroll controller is in OverscrollStateActionReady.
 @property(nonatomic, assign) CGPoint panPointScreenOrigin;
 // Pan gesture recognizer used to track horizontal touches.
 @property(nonatomic, retain) UIPanGestureRecognizer* panGestureRecognizer;
 
 // Registers notifications to lock the overscroll actions on certain UI states.
 - (void)registerNotifications;
 // Setup/tearDown methods are used to register values when the delegate is set.
 - (void)tearDown;
 - (void)setup;
 // Resets scroll view's top content inset to |self.initialContentInset|.
 - (void)resetScrollViewTopContentInset;
 // Access the headerView from the delegate.
 - (UIView<RelaxedBoundsConstraintsHitTestSupport>*)headerView;
 // Locking/unlocking methods used to disable/enable the overscroll actions
 // with a reference count.
 - (void)incrementOverscrollActionLockForNotification:
     (NSNotification*)notification;
 - (void)decrementOverscrollActionLockForNotification:
     (NSNotification*)notification;
 // Indicates whether the overscroll action is allowed.
 - (BOOL)isOverscrollActionEnabled;
 // Triggers a call to delegate if an action has been triggered.
 - (void)triggerActionIfNeeded;
 // Performs work based on overscroll action state changes.
 - (void)onOverscrollStateChangeWithPreviousState:
-    (ios_internal::OverscrollState)previousOverscrollState;
+    (OverscrollState)previousOverscrollState;
 // Disables all interactions on the webview except pan.
 - (void)setWebViewInteractionEnabled:(BOOL)enabled;
 // Bounce dynamic animations methods.
 // Starts the bounce animation with an initial velocity.
 - (void)startBounceWithInitialVelocity:(CGPoint)velocity;
 // Stops bounce animation.
 - (void)stopBounce;
 // Called from the display link to update the bounce dynamic animation.
 - (void)updateBounce;
 // Applies bounce state to the scroll view.
@@ skipping 61 matching lines @@
   [self tearDown];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [self setWebViewInteractionEnabled:YES];
   _delegate = nil;
   _webViewProxy.reset();
   [_webViewScrollViewProxy removeObserver:self];
   _webViewScrollViewProxy.reset();
 }
 
 - (void)clear {
-  self.overscrollState = ios_internal::OverscrollState::NO_PULL_STARTED;
+  self.overscrollState = OverscrollState::NO_PULL_STARTED;
 }
 
 - (void)enableOverscrollActions {
   _isOverscrollActionsDisabledForLoading = NO;
   [self setup];
 }
 
 - (void)disableOverscrollActions {
   _isOverscrollActionsDisabledForLoading = YES;
   [self tearDown];
 }
 
-- (void)setStyle:(ios_internal::OverscrollStyle)style {
+- (void)setStyle:(OverscrollStyle)style {
   [self.overscrollActionView setStyle:style];
 }
 
 #pragma mark - webViewScrollView and UIScrollView delegates implementations
 
 - (void)scrollViewDidScroll {
   if (!_forceStateUpdate && (![self isOverscrollActionEnabled] ||
                              _performingScrollViewIndependentAnimation))
     return;
 
   const UIEdgeInsets insets =
       UIEdgeInsetsMake(-[self scrollView].contentOffset.y, 0, 0, 0);
   // Start pulling (on top).
   CGFloat contentOffsetFromTheTop = [self scrollView].contentOffset.y;
   if (![_webViewProxy shouldUseInsetForTopPadding]) {
     // Content offset is shifted for WKWebView when the web view's
     // |shouldUseInsetForTopPadding| is NO, to workaround bug with
     // UIScollView.contentInset (rdar://23584409).
     contentOffsetFromTheTop -= [_webViewProxy topContentPadding];
   }
   CGFloat contentOffsetFromExpandedHeader =
       contentOffsetFromTheTop + self.initialHeaderInset;
   if (contentOffsetFromExpandedHeader >= 0) {
     // Record initial content offset and dispatch delegate on state change.
-    self.overscrollState = ios_internal::OverscrollState::NO_PULL_STARTED;
+    self.overscrollState = OverscrollState::NO_PULL_STARTED;
   } else {
     if (contentOffsetFromExpandedHeader < -kHeaderMaxExpansionThreshold) {
-      self.overscrollState = ios_internal::OverscrollState::ACTION_READY;
+      self.overscrollState = OverscrollState::ACTION_READY;
       [self scrollView].scrollIndicatorInsets = insets;
     } else {
       // Set the contentInset to remove the bounce that would fight with drag.
       [self setScrollViewContentInset:insets];
       [self scrollView].scrollIndicatorInsets = insets;
-      self.overscrollState = ios_internal::OverscrollState::STARTED_PULLING;
+      self.overscrollState = OverscrollState::STARTED_PULLING;
     }
     [self updateWithVerticalOffset:-contentOffsetFromExpandedHeader];
   }
 }
 
 - (void)scrollViewWillBeginDragging {
   [self stopBounce];
   _allowPullingActions = NO;
   _didTransitionToActionReady = NO;
   [self.overscrollActionView pullStarted];
   if (!_performingScrollViewIndependentAnimation)
     _allowPullingActions = [self isOverscrollActionsAllowed];
   _lastScrollBeginTime = CACurrentMediaTime();
 }
 
 - (BOOL)isOverscrollActionsAllowed {
   const BOOL isZooming = [[self scrollView] isZooming];
   // Check that the scrollview is scrolled to top.
   const BOOL isScrolledToTop = fabs([[self scrollView] contentOffset].y +
                                     [[self scrollView] contentInset].top) <=
                                kScrolledToTopToleranceInPoint;
   // Check that the user is not quickly scrolling the view repeatedly.
   const BOOL isMinimumTimeBetweenScrollRespected =
       (CACurrentMediaTime() - _lastScrollBeginTime) >=
       kMinimumDurationBetweenScrollingInSeconds;
   // Finally check that the delegate allow overscroll actions.
   const BOOL delegateAllowOverscrollActions =
       [self.delegate shouldAllowOverscrollActions];
   const BOOL isCurrentlyProcessingOverscroll =
-      self.overscrollState != ios_internal::OverscrollState::NO_PULL_STARTED;
+      self.overscrollState != OverscrollState::NO_PULL_STARTED;
   return isCurrentlyProcessingOverscroll ||
          (isScrolledToTop && isMinimumTimeBetweenScrollRespected &&
           delegateAllowOverscrollActions && !isZooming);
 }
 
 - (void)scrollViewDidEndDraggingWillDecelerate:(BOOL)decelerate
                                  contentOffset:(CGPoint)contentOffset {
   // Content is now hidden behind toolbar, make sure that contentInset is
   // restored to initial value.
   if (contentOffset.y >= 0 ||
-      self.overscrollState == ios_internal::OverscrollState::NO_PULL_STARTED) {
+      self.overscrollState == OverscrollState::NO_PULL_STARTED) {
     [self resetScrollViewTopContentInset];
   }
 
   [self triggerActionIfNeeded];
   _allowPullingActions = NO;
 }
 
 - (void)scrollViewWillEndDraggingWithVelocity:(CGPoint)velocity
                           targetContentOffset:
                               (inout CGPoint*)targetContentOffset {
   if (![self isOverscrollActionEnabled])
     return;
 
-  if (self.overscrollState != ios_internal::OverscrollState::NO_PULL_STARTED) {
+  if (self.overscrollState != OverscrollState::NO_PULL_STARTED) {
     *targetContentOffset = [[self scrollView] contentOffset];
     [self startBounceWithInitialVelocity:velocity];
   }
 }
 
 - (void)webViewScrollViewProxyDidSetScrollView:
     (CRWWebViewScrollViewProxy*)webViewScrollViewProxy {
   [self setup];
 }
 
@@ skipping 59 matching lines @@
 #pragma mark - Pan gesture recognizer handling
 
 - (void)panGesture:(UIPanGestureRecognizer*)gesture {
   if (gesture.state == UIGestureRecognizerStateBegan) {
     [self setWebViewInteractionEnabled:NO];
   } else if (gesture.state == UIGestureRecognizerStateEnded ||
              gesture.state == UIGestureRecognizerStateCancelled) {
     [self setWebViewInteractionEnabled:YES];
   }
   const CGPoint panPointScreen = [gesture locationInView:nil];
-  if (self.overscrollState == ios_internal::OverscrollState::ACTION_READY) {
+  if (self.overscrollState == OverscrollState::ACTION_READY) {
     const CGFloat direction = UseRTLLayout() ? -1 : 1;
     const CGFloat xOffset = direction *
                             (panPointScreen.x - self.panPointScreenOrigin.x) /
                             kHorizontalPanDistance;
 
     [self.overscrollActionView updateWithHorizontalOffset:xOffset];
   }
 }
 
 - (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
@@ skipping 18 matching lines @@
 
 - (void)webControllerWillClose:(CRWWebController*)webController {
   [self disableOverscrollActions];
   [_webViewScrollViewProxy removeObserver:self];
   _webViewScrollViewProxy.reset();
   [webController removeObserver:self];
 }
 
 #pragma mark - Private
 
-- (void)recordMetricForTriggeredAction:(ios_internal::OverscrollAction)action {
+- (void)recordMetricForTriggeredAction:(OverscrollAction)action {
   switch (action) {
-    case ios_internal::OverscrollAction::NONE:
+    case OverscrollAction::NONE:
       UMA_HISTOGRAM_ENUMERATION(kOverscrollActionsHistogram,
                                 OVERSCROLL_ACTION_CANCELED,
                                 OVERSCROLL_ACTION_COUNT);
       break;
-    case ios_internal::OverscrollAction::NEW_TAB:
+    case OverscrollAction::NEW_TAB:
       UMA_HISTOGRAM_ENUMERATION(kOverscrollActionsHistogram,
                                 OVERSCROLL_ACTION_NEW_TAB,
                                 OVERSCROLL_ACTION_COUNT);
       break;
-    case ios_internal::OverscrollAction::REFRESH:
+    case OverscrollAction::REFRESH:
       UMA_HISTOGRAM_ENUMERATION(kOverscrollActionsHistogram,
                                 OVERSCROLL_ACTION_REFRESH,
                                 OVERSCROLL_ACTION_COUNT);
       break;
-    case ios_internal::OverscrollAction::CLOSE_TAB:
+    case OverscrollAction::CLOSE_TAB:
       UMA_HISTOGRAM_ENUMERATION(kOverscrollActionsHistogram,
                                 OVERSCROLL_ACTION_CLOSE_TAB,
                                 OVERSCROLL_ACTION_COUNT);
       break;
   }
 }
 
 - (void)registerNotifications {
   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
   for (NSString* counterpartNotificationName in _lockNotificationsCounterparts
@@ skipping 66 matching lines @@
   NSString* counterpartName =
       [_lockNotificationsCounterparts objectForKey:notif.name];
   if ([_lockIncrementNotifications containsObject:counterpartName]) {
     [_lockIncrementNotifications removeObject:counterpartName];
     if (_overscrollActionLock > 0)
       --_overscrollActionLock;
   }
 }
 
 - (void)deviceOrientationDidChange {
-  if (self.overscrollState == ios_internal::OverscrollState::NO_PULL_STARTED &&
+  if (self.overscrollState == OverscrollState::NO_PULL_STARTED &&
       !_performingScrollViewIndependentAnimation)
     return;
 
   const UIDeviceOrientation deviceOrientation =
       [[UIDevice currentDevice] orientation];
   if (deviceOrientation != UIDeviceOrientationLandscapeRight &&
       deviceOrientation != UIDeviceOrientationLandscapeLeft &&
       deviceOrientation != UIDeviceOrientationPortrait) {
     return;
   }
@@ skipping 11 matching lines @@
 }
 
 - (BOOL)isOverscrollActionEnabled {
   return _overscrollActionLock == 0 && _allowPullingActions &&
          !_isOverscrollActionsDisabledForLoading;
 }
 
 - (void)triggerActionIfNeeded {
   if ([self isOverscrollActionEnabled]) {
     const BOOL isOverscrollStateActionReady =
-        self.overscrollState == ios_internal::OverscrollState::ACTION_READY;
+        self.overscrollState == OverscrollState::ACTION_READY;
     const BOOL isOverscrollActionNone =
-        self.overscrollActionView.selectedAction ==
-        ios_internal::OverscrollAction::NONE;
+        self.overscrollActionView.selectedAction == OverscrollAction::NONE;
 
     if ((!isOverscrollStateActionReady && _didTransitionToActionReady) ||
         (isOverscrollStateActionReady && isOverscrollActionNone)) {
-      [self
-          recordMetricForTriggeredAction:ios_internal::OverscrollAction::NONE];
+      [self recordMetricForTriggeredAction:OverscrollAction::NONE];
     } else if (isOverscrollStateActionReady && !isOverscrollActionNone) {
       if (CACurrentMediaTime() - _lastScrollBeginTime >=
           kMinimumPullDurationToTriggerActionInSeconds) {
         _performingScrollViewIndependentAnimation = YES;
         [self setScrollViewContentInset:UIEdgeInsetsMake(
                                             self.initialContentInset, 0, 0, 0)];
         CGPoint contentOffset = [[self scrollView] contentOffset];
         contentOffset.y = -self.initialContentInset;
         [[self scrollView] setContentOffset:contentOffset animated:YES];
         [self.overscrollActionView displayActionAnimation];
         dispatch_async(dispatch_get_main_queue(), ^{
           [self recordMetricForTriggeredAction:self.overscrollActionView
                                                    .selectedAction];
           [self.delegate overscrollActionsController:self
                                     didTriggerAction:self.overscrollActionView
                                                          .selectedAction];
         });
       }
     }
   }
 }
 
-- (void)setOverscrollState:(ios_internal::OverscrollState)overscrollState {
+- (void)setOverscrollState:(OverscrollState)overscrollState {
   if (_overscrollState != overscrollState) {
-    const ios_internal::OverscrollState previousState = _overscrollState;
+    const OverscrollState previousState = _overscrollState;
     _overscrollState = overscrollState;
     [self onOverscrollStateChangeWithPreviousState:previousState];
   }
 }
 
 - (void)onOverscrollStateChangeWithPreviousState:
-    (ios_internal::OverscrollState)previousOverscrollState {
+    (OverscrollState)previousOverscrollState {
   [UIView beginAnimations:@"backgroundColor" context:NULL];
   switch (self.overscrollState) {
-    case ios_internal::OverscrollState::NO_PULL_STARTED: {
+    case OverscrollState::NO_PULL_STARTED: {
       UIView<RelaxedBoundsConstraintsHitTestSupport>* headerView =
           [self headerView];
       if ([headerView
               respondsToSelector:@selector(setHitTestBoundsContraintRelaxed:)])
         [headerView setHitTestBoundsContraintRelaxed:NO];
       [self.overscrollActionView removeFromSuperview];
       SetViewFrameHeight(
           self.overscrollActionView,
           self.initialContentInset +
               [UIApplication sharedApplication].statusBarFrame.size.height);
       self.panPointScreenOrigin = CGPointZero;
       [[NSNotificationCenter defaultCenter]
-          postNotificationName:ios_internal::kOverscollActionsDidEnd
+          postNotificationName:kOverscrollActionsDidEnd
                         object:self];
     } break;
-    case ios_internal::OverscrollState::STARTED_PULLING: {
+    case OverscrollState::STARTED_PULLING: {
       if (!self.overscrollActionView.superview) {
-        if (previousOverscrollState ==
-            ios_internal::OverscrollState::NO_PULL_STARTED) {
+        if (previousOverscrollState == OverscrollState::NO_PULL_STARTED) {
           UIView* view = [self.delegate toolbarSnapshotView];
           [self.overscrollActionView addSnapshotView:view];
           [[NSNotificationCenter defaultCenter]
-              postNotificationName:ios_internal::kOverscollActionsWillStart
+              postNotificationName:kOverscrollActionsWillStart
                             object:self];
         }
         [CATransaction begin];
         [CATransaction setDisableActions:YES];
         self.overscrollActionView.backgroundView.alpha = 1;
         [self.overscrollActionView updateWithVerticalOffset:0];
         [self.overscrollActionView updateWithHorizontalOffset:0];
         self.overscrollActionView.frame = [self headerView].bounds;
         DCHECK([self headerView]);
         UIView<RelaxedBoundsConstraintsHitTestSupport>* headerView =
             [self headerView];
         if ([headerView
                 respondsToSelector:@selector(
                                        setHitTestBoundsContraintRelaxed:)])
           [headerView setHitTestBoundsContraintRelaxed:YES];
         [headerView addSubview:self.overscrollActionView];
         [CATransaction commit];
       }
     } break;
-    case ios_internal::OverscrollState::ACTION_READY: {
+    case OverscrollState::ACTION_READY: {
       _didTransitionToActionReady = YES;
       if (CGPointEqualToPoint(self.panPointScreenOrigin, CGPointZero)) {
         CGPoint panPointScreen = [self.panGestureRecognizer locationInView:nil];
         self.panPointScreenOrigin = panPointScreen;
       }
     } break;
   }
   [UIView commitAnimations];
 }
 
@@ skipping 56 matching lines @@
 #pragma mark - Bounce dynamic
 
 - (void)startBounceWithInitialVelocity:(CGPoint)velocity {
   [self stopBounce];
   CADisplayLink* dpLink =
       [CADisplayLink displayLinkWithTarget:self
                                   selector:@selector(updateBounce)];
   [dpLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
   _dpLink = dpLink;
   memset(&_bounceState, 0, sizeof(_bounceState));
-  if (self.overscrollState == ios_internal::OverscrollState::ACTION_READY) {
+  if (self.overscrollState == OverscrollState::ACTION_READY) {
     const UIEdgeInsets insets = UIEdgeInsetsMake(
         -[self scrollView].contentOffset.y + self.initialContentInset, 0, 0, 0);
     [self setScrollViewContentInset:insets];
     [[self scrollView] setScrollIndicatorInsets:insets];
   }
   _bounceState.yInset = [self scrollView].contentInset.top;
   _bounceState.initialYInset = _bounceState.yInset;
   _bounceState.headerInset = self.initialContentInset;
   _bounceState.time = CACurrentMediaTime();
   _bounceState.velocityInset = -velocity.y * 1000.0;
 }
 
 - (void)stopBounce {
   [_dpLink invalidate];
   _dpLink = nil;
   if (_performingScrollViewIndependentAnimation) {
-    self.overscrollState = ios_internal::OverscrollState::NO_PULL_STARTED;
+    self.overscrollState = OverscrollState::NO_PULL_STARTED;
     _performingScrollViewIndependentAnimation = NO;
   }
 }
 
 - (void)updateBounce {
   const double time = CACurrentMediaTime();
   const double dt = time - _bounceState.time;
   CGFloat force = -_bounceState.yInset * kSpringTightness;
   if (_bounceState.yInset > _bounceState.headerInset)
     force -= _bounceState.velocityInset * kSpringDampiness;
@@ skipping 34 matching lines @@
   _panGestureRecognizer.enabled = YES;
   [self scrollView].panGestureRecognizer.enabled = NO;
   [self scrollView].panGestureRecognizer.enabled = YES;
   [self startBounceWithInitialVelocity:CGPointZero];
   [self.delegate
       overscrollActionsController:self
                  didTriggerAction:self.overscrollActionView.selectedAction];
 }
 
 @end