Make it possible to test that the stock app doesn't crash on startup and paints the basic scaffold …

sky/sdk/lib/framework/widgets/ui_node.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../app.dart';
@@ skipping 729 matching lines @@
     }
 
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
 }
 
 
 class UINodeAppView extends AppView {
 
-  UINodeAppView() {
+  UINodeAppView({ RenderView renderViewOverride: null })
+      : super(renderViewOverride: renderViewOverride) {
     assert(_appView == null);
   }
 
   static UINodeAppView _appView;
   static AppView get appView => _appView;
-  static void initUINodeAppView() {
-    if (_appView == null)
-      _appView = new UINodeAppView();
+  static void initUINodeAppView({ RenderView renderViewOverride: null }) {
+    _appView = new UINodeAppView(renderViewOverride: renderViewOverride);
   }
 
   void dispatchEvent(sky.Event event, HitTestResult result) {
     assert(_appView == this);
     super.dispatchEvent(event, result);
     for (HitTestEntry entry in result.path.reversed) {
       UINode target = RenderObjectWrapper._getMounted(entry.target);
       if (target == null)
         continue;
       RenderObject targetRoot = target.root;
       while (target != null && target.root == targetRoot) {
         if (target is EventListenerNode)
           target._handleEvent(event);
         target = target._parent;
       }      
     }
   }
 
 }
 
 abstract class AbstractUINodeRoot extends Component {
 
-  AbstractUINodeRoot() : super(stateful: true) {
-    UINodeAppView.initUINodeAppView();
+  AbstractUINodeRoot({ RenderView renderViewOverride }) : super(stateful: true) {
+    UINodeAppView.initUINodeAppView(renderViewOverride: renderViewOverride);
     _mounted = true;
     _scheduleComponentForRender(this);
   }
 
   void syncFields(AbstractUINodeRoot source) {
     assert(false);
     // if we get here, it implies that we have a parent
   }
 
   void _buildIfDirty() {
     assert(_dirty);
     assert(_mounted);
     assert(parent == null);
     _sync(null, null);
   }
 
 }
 
 abstract class App extends AbstractUINodeRoot {
 
-  App();
+  App({ RenderView renderViewOverride }) : super(renderViewOverride: renderViewOverride);
 
   void _buildIfDirty() {
     super._buildIfDirty();
 
     if (root.parent == null) {
       // we haven't attached it yet
       UINodeAppView._appView.root = root;
     }
     assert(root.parent is RenderView);
   }
 
 }
 
 typedef UINode Builder();
 
 class RenderObjectToUINodeAdapter extends AbstractUINodeRoot {
 
   RenderObjectToUINodeAdapter(
     RenderObjectWithChildMixin<RenderBox> container,
     this.builder
-  ) : _container = container {
+  ) : _container = container, super() {
     assert(builder != null);
   }
 
   RenderObjectWithChildMixin<RenderBox> _container;
   RenderObjectWithChildMixin<RenderBox> get container => _container;
   void set container(RenderObjectWithChildMixin<RenderBox> value) {
     if (_container != value) {
       assert(value.child == null);
       if (root != null) {
         assert(_container.child == root);
@@ skipping 15 matching lines @@
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   UINode build() => builder();
 
 }