Roll Polymer

third_party/polymer/v1_0/components-chromium/iron-location/iron-location-extracted.js

 'use strict';
 
   Polymer({
     is: 'iron-location',
     properties: {
       /**
        * The pathname component of the URL.
        */
       path: {
         type: String,
@@ skipping 55 matching lines @@
 
       /**
        * urlSpaceRegex, but coerced into a regexp.
        *
        * @type {RegExp}
        */
       _urlSpaceRegExp: {
         computed: '_makeRegExp(urlSpaceRegex)'
       },
 
-      _lastChangedAtAt: {
-        type: Number,
-        value: -Infinity
+      _lastChangedAt: {
+        type: Number
       },
 
       _initialized: {
         type: Boolean,
         value: false
       }
     },
     hostAttributes: {
       hidden: true
     },
     observers: [
       '_updateUrl(path, query, hash)'
     ],
     attached: function() {
       this.listen(window, 'hashchange', '_hashChanged');
       this.listen(window, 'location-changed', '_urlChanged');
       this.listen(window, 'popstate', '_urlChanged');
       this.listen(/** @type {!HTMLBodyElement} */(document.body), 'click', '_globalOnClick');
+      // Give a 200ms grace period to make initial redirects without any
+      // additions to the user's history.
+      this._lastChangedAt = window.performance.now() - (this.dwellTime - 200);
 
       this._initialized = true;
       this._urlChanged();
     },
     detached: function() {
       this.unlisten(window, 'hashchange', '_hashChanged');
       this.unlisten(window, 'location-changed', '_urlChanged');
       this.unlisten(window, 'popstate', '_urlChanged');
       this.unlisten(/** @type {!HTMLBodyElement} */(document.body), 'click', '_globalOnClick');
       this._initialized = false;
     },
-    /**
-     * @return {number} the number of milliseconds since some point in the
-     *     past. Only useful for comparing against other results from this
-     *     function.
-     */
-    _now: function() {
-      if (window.performance && window.performance.now) {
-        return window.performance.now();
-      }
-      return new Date().getTime();
-    },
     _hashChanged: function() {
       this.hash = window.location.hash.substring(1);
     },
     _urlChanged: function() {
       // We want to extract all info out of the updated URL before we
       // try to write anything back into it.
       //
       // i.e. without _dontUpdateUrl we'd overwrite the new path with the old
       // one when we set this.hash. Likewise for query.
       this._dontUpdateUrl = true;
@@ skipping 24 matching lines @@
           window.location.search +
           window.location.hash
       );
       if (newUrl == currentUrl) {
         // nothing to do, the URL didn't change
         return;
       }
       // Need to use a full URL in case the containing page has a base URI.
       var fullNewUrl = new URL(
           newUrl, window.location.protocol + '//' + window.location.host).href;
-      var now = this._now();
+      var now = window.performance.now();
       var shouldReplace =
           this._lastChangedAt + this.dwellTime > now;
       this._lastChangedAt = now;
       if (shouldReplace) {
         window.history.replaceState({}, '', fullNewUrl);
       } else {
         window.history.pushState({}, '', fullNewUrl);
       }
       this.fire('location-changed', {}, {node: window});
     },
     /**
      * A necessary evil so that links work as expected. Does its best to
      * bail out early if possible.
      *
      * @param {MouseEvent} event .
      */
     _globalOnClick: function(event) {
+      // If another event handler has stopped this event then there's nothing
+      // for us to do. This can happen e.g. when there are multiple
+      // iron-location elements in a page.
+      if (event.defaultPrevented) {
+        return;
+      }
       var href = this._getSameOriginLinkHref(event);
       if (!href) {
         return;
       }
       window.history.pushState({}, '', href);
       this.fire('location-changed', {}, {node: window});
       event.preventDefault();
     },
     /**
      * Returns the absolute URL of the link (if any) that this click event
@@ skipping 18 matching lines @@
       for (var i = 0; i < eventPath.length; i++) {
         var element = eventPath[i];
         if (element.tagName === 'A' && element.href) {
           anchor = element;
           break;
         }
       }
 
       // If there's no link there's nothing to do.
       if (!anchor) {
-        return;
+        return null;
       }
 
       // Target blank is a new tab, don't intercept.
       if (anchor.target === '_blank') {
-        return;
+        return null;
       }
       // If the link is for an existing parent frame, don't intercept.
       if ((anchor.target === '_top' ||
            anchor.target === '_parent') &&
           window.top !== window) {
-        return;
+        return null;
       }
 
       var href = anchor.href;
 
       // It only makes sense for us to intercept same-origin navigations.
       // pushState/replaceState don't work with cross-origin links.
       var url;
       if (document.baseURI != null) {
         url = new URL(href, /** @type {string} */(document.baseURI));
       } else {
@@ skipping 19 matching lines @@
       var normalizedHref = url.pathname + url.search + url.hash;
 
       // If we've been configured not to handle this url... don't handle it!
       if (this._urlSpaceRegExp &&
           !this._urlSpaceRegExp.test(normalizedHref)) {
         return null;
       }
       // Need to use a full URL in case the containing page has a base URI.
       var fullNormalizedHref = new URL(
           normalizedHref, window.location.href).href;
+      // If the navigation is to the current page we shouldn't add a history
+      // entry.
+      if (fullNormalizedHref === window.location.href) {
+        return null;
+      }
       return fullNormalizedHref;
     },
     _makeRegExp: function(urlSpaceRegex) {
       return RegExp(urlSpaceRegex);
     }
   });