fixes css tests, now they can also run in browsers too.

utils/css/tokenizer.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class Tokenizer extends CSSTokenizerBase {
   TokenKind cssTokens;
 
   bool _selectorParsing;
 
   Tokenizer(SourceFile source, bool skipWhitespace, [int index = 0])
@@ skipping 140 matching lines @@
           return _finishToken(TokenKind.SUFFIX_MATCH);    // $=
         } else {
           return _finishToken(TokenKind.DOLLAR);
         }
       case cssTokens.tokens[TokenKind.BANG]:
         Token tok = finishIdentifier(ch);
         return (tok == null) ? _finishToken(TokenKind.BANG) : tok;
       default:
         if (TokenizerHelpers.isIdentifierStart(ch)) {
           return this.finishIdentifier(ch);
-        } else if (isDigit(ch)) {
+        } else if (TokenizerHelpers.isDigit(ch)) {
           return this.finishNumber();
         } else {
           return _errorToken();
         }
     }
   }
 
   // TODO(jmesserly): we need a way to emit human readable error messages from
   // the tokenizer.
   Token _errorToken([String message = null]) {
     return _finishToken(TokenKind.ERROR);
   }
 
   int getIdentifierKind() {
     // Is the identifier a unit type?
     int tokId = TokenKind.matchUnits(_text, _startIndex, _index - _startIndex);
     if (tokId == -1) {
       // No, is it a directive?
-      tokId = TokenKind.matchDirectives(_text, _startIndex, _index - _startIndex);
+      tokId = TokenKind.matchDirectives(
+          _text, _startIndex, _index - _startIndex);
     }
     if (tokId == -1) {
       tokId = (_text.substring(_startIndex, _index) == '!important') ?
           TokenKind.IMPORTANT : -1;
     }
 
     return tokId >= 0 ? tokId : TokenKind.IDENTIFIER;
   }
 
   // Need to override so CSS version of isIdentifierPart is used.
@@ skipping 21 matching lines @@
   Token finishImportant() {
     
   }
 
   Token finishNumber() {
     eatDigits();
 
     if (_peekChar() == 46/*.*/) {
       // Handle the case of 1.toString().
       _nextChar();
-      if (isDigit(_peekChar())) {
+      if (TokenizerHelpers.isDigit(_peekChar())) {
         eatDigits();
         return _finishToken(TokenKind.DOUBLE);
       } else {
         _index -= 1;
       }
     }
 
     return _finishToken(TokenKind.INTEGER);
   }
 
   bool maybeEatDigit() {
-    if (_index < _text.length && isDigit(_text.charCodeAt(_index))) {
+    if (_index < _text.length
+        && TokenizerHelpers.isDigit(_text.charCodeAt(_index))) {
       _index += 1;
       return true;
     }
     return false;
   }
 
   void eatHexDigits() {
     while (_index < _text.length) {
-     if (isHexDigit(_text.charCodeAt(_index))) {
+     if (TokenizerHelpers.isHexDigit(_text.charCodeAt(_index))) {
        _index += 1;
      } else {
        return;
      }
     }
   }
 
   bool maybeEatHexDigit() {
-    if (_index < _text.length && isHexDigit(_text.charCodeAt(_index))) {
+    if (_index < _text.length
+        && TokenizerHelpers.isHexDigit(_text.charCodeAt(_index))) {
       _index += 1;
       return true;
     }
     return false;
   }
 
   Token finishMultiLineComment() {
     while (true) {
       int ch = _nextChar();
       if (ch == 0) {
@@ skipping 31 matching lines @@
   static bool isIdentifierStart(int c) {
     return ((c >= 97/*a*/ && c <= 122/*z*/) || (c >= 65/*A*/ && c <= 90/*Z*/) ||
         c == 95/*_*/ || c == 45 /*-*/);
   }
 
   static bool isDigit(int c) {
     return (c >= 48/*0*/ && c <= 57/*9*/);
   }
 
   static bool isHexDigit(int c) {
-    return (isDigit(c) || (c >= 97/*a*/ && c <= 102/*f*/) || (c >= 65/*A*/ && c <= 70/*F*/));
-  }
-
-  static bool isWhitespace(int c) {
-    return (c == 32/*' '*/ || c == 9/*'\t'*/ || c == 10/*'\n'*/ || c == 13/*'\r'*/);
+    return (isDigit(c) || (c >= 97/*a*/ && c <= 102/*f*/)
+        || (c >= 65/*A*/ && c <= 70/*F*/));
   }
 
   static bool isIdentifierPart(int c) {
     return (isIdentifierStart(c) || isDigit(c) || c == 45 /*-*/);
   }
-
-  static bool isInterpIdentifierPart(int c) {
-    return (isIdentifierStart(c) || isDigit(c));
-  }
 }