anchor.diff:    // Track overlays for z-index and focus managemant.
     static List overlays = [];
   
  -  static void trackOverlays(inOverlay) {
  +  static void _trackOverlays(inOverlay) {
       if (inOverlay.opened) {
  -      var z0 = currentOverlayZ();
  +      var z0 = _currentOverlayZ();
         overlays.add(inOverlay);
  -      var z1 = currentOverlayZ();
  +      var z1 = _currentOverlayZ();
         if (z0 != null && z1 != null && z1 <= z0) {
  -        applyOverlayZ(inOverlay, z0);
  +        _applyOverlayZ(inOverlay, z0);
         }
       } else {
         var i = overlays.indexOf(inOverlay);
         if (i >= 0) {
           overlays.removeAt(i);
  -        setZ(inOverlay, null);
  +        _setZ(inOverlay, null);
         }
       }
     }
   
  -  static void applyOverlayZ(inOverlay, inAboveZ) {
  -    setZ(inOverlay, inAboveZ + 2);
  -  }
  -
  -  static void setZ(inNode, inZ) {
  +  static void _applyOverlayZ(inOverlay, inAboveZ) {
  +    _setZ(inOverlay, inAboveZ + 2);
  +  }
  +
  +  static void _setZ(inNode, inZ) {
       inNode.style.zIndex = "$inZ";
     }
   
  -  static currentOverlay() {
  +  static _currentOverlay() {
       return overlays.isNotEmpty ? overlays.last : null;
     }
   
  -  static int DEFAULT_Z = 1000;
  -
  -  static currentOverlayZ() {
  -    var z = DEFAULT_Z;
  -    var current = currentOverlay();
  +  // TODO(ussuri): This widget doesn't know in which z-index environment it's
  +  // going to live. Choosing an arbitrary starting z-index here is wrong. Redo.
  +  static int _DEFAULT_Z = 1000;
  +
  +  static _currentOverlayZ() {
  +    var z = _DEFAULT_Z;
  +    var current = _currentOverlay();
       if (current != null) {
  -      var z1 = current.getComputedStyle().zIndex;
  +      final z1 = current.getComputedStyle().zIndex;
         z = int.parse(z1, onError: (source) { });
       }
       return z;
     }
   
  -  static void focusOverlay() {
  -    var current = currentOverlay();
  +  static void _focusOverlay() {
  +    var current = _currentOverlay();
       if (current != null) {
         current.focus();
       }
  
positive.code:   }
  
    void openedChanged() {
      renderOpened();
      trackOverlays(this);
  
      _enableResizeHandler(opened);
  
  
negative.code: 
    void _enableResizeHandler(inEnable) {
      if (inEnable) {
        window.addEventListener('resize', _resizeHandlerInst);
      } else {
        window.removeEventListener('resize', _resizeHandlerInst);
      }
    }
  
    void _enableCaptureHandler(bool enable, Iterable<String> eventTypes) {
      final Function addRemoveFunc =
          enable ? document.addEventListener : document.removeEventListener;
      eventTypes.forEach((et) => addRemoveFunc(et, _captureHandlerInst, true));
    }
  
    void _applyFocus() {
      if (opened) {
        focus();
      } else {
        // Focus the next overlay in the stack.
        _focusOverlay();
      }
    }
  
    void _renderOpened() {
      classes.remove('closing');
      classes.add('revealed');
      // continue styling after delay so display state can change without
      // aborting transitions
      Timer.run(() { _continueRenderOpened(); });
  //    asyncMethod('continueRenderOpened');
    }
  
    void _continueRenderOpened() {
      classes.toggle('opened', opened);
      classes.toggle('closing', !opened);
  //    this.animating = this.asyncMethod('completeOpening', null, this.timeout);
    }
  
    void _completeOpening() {
  //    clearTimeout(this.animating);
      classes.remove('closing');
      classes.toggle('revealed', opened);
      _applyFocus();
    }
  
    void _openedAnimationEnd(AnimationEvent e) {
      if (!opened) {
        classes.remove('animation-in-progress');
      }
      // same steps as when a transition ends
      _openedTransitionEnd(e);
    }
  
    void _openedTransitionEnd(Event e) {
      // TODO(sorvell): Necessary due to
      // https://bugs.webkit.org/show_bug.cgi?id=107892
      // Remove when that bug is addressed.
      if (e.target == this) {
        _completeOpening();
        e.stopImmediatePropagation();
        e.preventDefault();
      }
    }
  
    void _openedAnimationStart(AnimationEvent e) {
      classes.add('animation-in-progress');
      e.stopImmediatePropagation();
      e.preventDefault();
    }
  
    void _tapHandler(MouseEvent e) {
      Element target = e.target;
      if (target != null && target.attributes.containsKey('overlay-toggle')) {
        toggle();
      } else if (_autoCloseTask != null) {
        _autoCloseTask.cancel();
        _autoCloseTask = null;
      }
    }
  
    void _captureHandler(Event e) {
      final bool inOverlay =
          (e is MouseEvent && _isPointInOverlay(e.client)) ||
          this == e.target ||
          this.contains(e.target) ||
          shadowRoot.contains(e.target);
  