dart2js: remove JS_OBJECT_CLASS_NAME and JS_NULL_CLASS_NAME from foreign

sdk/lib/_internal/compiler/js_lib/js_rti.dart

 // Copyright (c) 2013, 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.
 
 /**
  * This part contains helpers for supporting runtime type information.
  *
  * The helper use a mixture of Dart and JavaScript objects. To indicate which is
  * used where we adopt the scheme of using explicit type annotation for Dart
  * objects and 'var' or omitted return type for JavaScript objects.
@@ skipping 346 matching lines @@
   var typeArguments = getRuntimeTypeArguments(context, contextName);
   return invokeOn(signature, context, typeArguments);
 }
 
 /**
  * Returns `true` if the runtime type representation [type] is a supertype of
  * [Null].
  */
 bool isSupertypeOfNull(var type) {
   // `null` means `dynamic`.
-  return type == null || getDartTypeName(type) == JS_OBJECT_CLASS_NAME()
-                      || getDartTypeName(type) == JS_NULL_CLASS_NAME();
+  return type == null || isDartObjectTypeRti(type) || isNullTypeRti(type);
 }
 
 /**
  * Tests whether the Dart object [o] is a subtype of the runtime type
  * representation [t].
  *
  * See the comment in the beginning of this file for a description of type
  * representations.
  */
 bool checkSubtypeOfRuntimeType(o, t) {
@@ skipping 58 matching lines @@
 bool isSubtype(var s, var t) {
   // Subtyping is reflexive.
   if (isIdentical(s, t)) return true;
   // If either type is dynamic, [s] is a subtype of [t].
   if (s == null || t == null) return true;
   if (isDartFunctionType(t)) {
     return isFunctionSubtype(s, t);
   }
   // Check function types against the Function class.
   if (isDartFunctionType(s)) {
-    return isDartFunctionTypeLiteral(t);
+    return isDartFunctionTypeRti(t);
   }
 
   // Get the object describing the class and check for the subtyping flag
   // constructed from the type of [t].
   var typeOfS = isJsArray(s) ? getIndex(s, 0) : s;
   var typeOfT = isJsArray(t) ? getIndex(t, 0) : t;
 
   // Check for a subtyping flag.
   // Get the necessary substitution of the type arguments, if there is one.
   var substitution;
@@ skipping 211 matching lines @@
  * `null` and `undefined` (which we can avoid).
  */
 bool isIdentical(var s, var t) => JS('bool', '# === #', s, t);
 
 /**
  * Returns `true` if the JavaScript values [s] and [t] are not identical. We use
  * this helper instead of [identical] because `identical` needs to merge
  * `null` and `undefined` (which we can avoid).
  */
 bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);