Removing an unnecessary throw for JS interop.

tools/dom/templates/html/impl/impl_Window.darttemplate

 // Copyright (c) 2012, 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.
 
 part of $LIBRARYNAME;
 
 $if DART2JS
 $(ANNOTATIONS)class $CLASSNAME$EXTENDS$IMPLEMENTS native "@*DOMWindow" {
 $else
 $(ANNOTATIONS)class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
 $endif
 
   /**
    * Executes a [callback] after the immediate execution stack has completed.
    *
    * This differs from using Timer.run(callback)
    * because Timer will run in about 4-15 milliseconds, depending on browser,
    * depending on load. [setImmediate], in contrast, makes browser-specific
    * changes in behavior to attempt to run immediately after the current
    * frame unwinds, causing the future to complete after all processing has
    * completed for the current event, but before any subsequent events.
    */
-  void setImmediate(TimeoutHandler callback) { 
+  void setImmediate(TimeoutHandler callback) {
     _addMicrotaskCallback(callback);
   }
   /**
    * Lookup a port by its [name].  Return null if no port is
    * registered under [name].
    */
   SendPortSync lookupPort(String name) {
-    var port =
-        json.parse(document.documentElement.attributes['dart-port:$name']);
+    var portStr = document.documentElement.attributes['dart-port:$name'];
+    if (portStr == null) {
+      return null;
+    }
+    var port = json.parse(portStr);
     return _deserialize(port);
   }
 
   /**
    * Register a [port] on this window under the given [name].  This
    * port may be retrieved by any isolate (or JavaScript script)
    * running in this window.
    */
   void registerPort(String name, var port) {
     var serialized = _serialize(port);
     document.documentElement.attributes['dart-port:$name'] =
         json.stringify(serialized);
   }
 
   /**
    * Returns a Future that completes just before the window is about to repaint
    * so the user can draw an animation frame
    *
    * If you need to later cancel this animation, use [requestAnimationFrame]
    * instead.
    *
-   * Note: The code that runs when the future completes should call 
+   * Note: The code that runs when the future completes should call
    * [animationFrame] again for the animation to continue.
    */
   Future<num> get animationFrame {
     var completer = new Completer<int>();
     requestAnimationFrame(completer.complete);
     return completer.future;
   }
 
 $if DART2JS
   Document get document => JS('Document', '#.document', this);
@@ skipping 55 matching lines @@
     // stub on Object.prototype and throws an exception.
     try {
       return thing is Location;
     } catch (e) {
       return false;
     }
   }
 
   /**
    * Called to draw an animation frame and then request the window to repaint
-   * after [callback] has finished (creating the animation). 
+   * after [callback] has finished (creating the animation).
    *
    * Use this method only if you need to later call [cancelAnimationFrame]. If
    * not, the preferred Dart idiom is to set animation frames by calling
    * [animationFrame], which returns a Future.
    *
    * Returns a non-zero valued integer to represent the request id for this
    * request. This value only needs to be saved if you intend to call
    * [cancelAnimationFrame] so you can specify the particular animation to
    * cancel.
    *
@@ skipping 74 matching lines @@
   static bool get _supportsSetImmediate => false;
 
   /// Dartium stub for IE's setImmediate.
   void _setImmediate(void callback()) {
     throw new UnsupportedError('setImmediate is not supported');
   }
 $endif
 
 $!MEMBERS
 }