anchor.diff:      } else {
         localUrl = ipfsUrl.replace(scheme: 'http', host: 'gateway.ipfs.io', port: 80);
       }
  -
  -    return new JsObject.jsify({
  -      'redirectUrl': localUrl.toString()
  +  }
  +
  +  String _handleOtherRequest(Uri url) {
  +    String redirectUrl = '';
  +
  +    var req = new HttpRequest();
  +    req.open('GET', 'http://${settings.host}:${settings.port}/ipns/${url.host}', async: false);
  +    req.onLoad.listen((event) {
  +      if ((event.target as HttpRequest).status < 400) {
  +        redirectUrl = 'http://${settings.host}:${settings.port}/ipns/${url.replace(scheme: '')}';
  +      }
       });
  +    req.send();
  +
  +    return redirectUrl;
  +  }
  +
  +  void _onErrorAction(JsObject details) {
  +    // Chrome will give an error message, but there isn't a defined way of
  +    // identifying the problem. Nor is there a way to tell Chrome how to
  +    // resolve the problem. Luckily Chrome will automatically reattempt the
  +    // request. We just have to be ready for it.
  +    _errorMode = true;
  +    _lastErrorTime = new DateTime.now();
  +    _generateRequestUrls();
  +    _setRequestListener();
  +  }
  +
  +  /**
  +   * This gets run on every single request the browser makes. It is pertinent
  +   * that it be FAST!
  +   */
  +  JsObject _onBeforeRequestAction(JsObject data) {
  +    Uri url;
  +    try {
  +      url = Uri.parse(data['url']);
  +    } on FormatException {
  +      // Some websites like to add invalid characters to their query strings
  +      // that their servers must like but the uri parser has beef with.
  +      // We'll just continue on with life like it never happened.
  +      return null;
  +    }
  +
  +    String redirectUrl = '';
  +    if (_isIpfsUrl(url)) {
  +      redirectUrl = _handleIpfsRequest(data, url);
  +    } else {
  +      redirectUrl = _handleOtherRequest(url);
  +    }
  +
  +    if (redirectUrl != '') {
  +      return new JsObject.jsify({
  +        'redirectUrl': redirectUrl
  +      });
  +    }
  +
  +    return null;
     }
   
     /**
  
positive.code:     dartifyChromeEvent(chromeWebRequest, 'onBeforeRequest')
          .callMethod('addListener', [
            _onBeforeRequestAction,
            new JsObject.jsify({'urls': _requestUrls}),
            new JsObject.jsify(['blocking'])
      ]);
    }
  
negative.code:     });
    }
  
    void _generateRequestUrls() {
      var urls = makeIpfsGlobs('file://');
      if (_errorMode) {
        urls.addAll(makeIpfsGlobs(settings.server));
      } else {
        urls.addAll(makeIpfsGlobs('http://gateway.ipfs.io'));
      }
      _ipfsRequestUrls = urls.map((url) => Uri.parse(url)).toList(growable: false);
    }
  
    bool _isIpfsUrl(Uri url) {
      bool urlMatch = false;
      if (url.pathSegments.isNotEmpty &&
          (url.pathSegments.first == 'ipfs' || url.pathSegments.first == 'ipns')) {
        urlMatch = url.host == settings.host && url.port == settings.port;
  
        for (int i = 0; i < _ipfsRequestUrls.length && !urlMatch; ++i) {
          urlMatch = _ipfsRequestUrls[i].host == url.host &&
                      _ipfsRequestUrls[i].port == url.port;
        }
      }
  
      return urlMatch;
    }
  
    String _handleIpfsRequest(JsObject data, Uri ipfsUrl) {
      if (_errorMode &&
          new DateTime.now().difference(_lastErrorTime) > _ERROR_COOL_DOWN_PERIOD) {
        _errorMode = false;
        _generateRequestUrls();
        _setRequestListener();
      }
  
      if (ipfsUrl.scheme == 'file') {
        ipfsUrl = _parseFileUrl(data['url']);
      }
  