Basic SSR support for error boundaries

src/core/__tests__/ReactErrorBoundaries-test.js

@@ -13,11 +13,13 @@
 
 var React;
 var ReactDOM;
+var ReactDOMServer;
 
 describe('ReactErrorBoundaries', function() {
 
   beforeEach(function() {
     ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
     React = require('React');
   });
 
@@ -55,6 +57,41 @@ describe('ReactErrorBoundaries', function() {
     expect(EventPluginHub.putListener).not.toBeCalled();
   });
 
+  it('renders an error state (ssr)', function() {
+    class Angry extends React.Component {
+      render() {
+        throw new Error('Please, do not render me.');
+      }
+    }
+
+    class Boundary extends React.Component {
+      constructor(props) {
+        super(props);
+        this.state = {error: false};
+      }
+      render() {
+        if (!this.state.error) {
+          return (<div><button onClick={this.onClick}>ClickMe</button><Angry /></div>);
+        } else {
+          return (<div>Happy Birthday!</div>);
+        }
+      }
+      onClick() {
+        /* do nothing */
+      }
+      unstable_handleError() {
+        this.setState({error: true});
+      }
+    }
+
+    var EventPluginHub = require('EventPluginHub');
+    var container = document.createElement('div');
+    EventPluginHub.putListener = jest.fn();
+    container.innerHTML = ReactDOMServer.renderToString(<Boundary />);
+    expect(container.firstChild.innerHTML).toBe('Happy Birthday!');
+    expect(EventPluginHub.putListener).not.toBeCalled();
+  });
+
   it('will catch exceptions in componentWillUnmount', function() {
     class ErrorBoundary extends React.Component {
       constructor() {

src/renderers/shared/reconciler/ReactCompositeComponent.js

@@ -413,20 +413,28 @@ var ReactCompositeComponentMixin = {
     context
   ) {
     var markup;
-    var checkpoint = transaction.checkpoint();
+    var canCheckpoint = !!transaction.checkpoint;
+    var checkpoint = canCheckpoint ? transaction.checkpoint() : null;
     try {
       markup = this.performInitialMount(renderedElement, nativeParent, nativeContainerInfo, transaction, context);
     } catch (e) {
       // Roll back to checkpoint, handle error (which may add items to the transaction), and take a new checkpoint
-      transaction.rollback(checkpoint);
+      if (canCheckpoint) {
+        transaction.rollback(checkpoint);
+      }
       this._instance.unstable_handleError(e);
       if (this._pendingStateQueue) {
         this._instance.state = this._processPendingState(this._instance.props, this._instance.context);
       }
-      checkpoint = transaction.checkpoint();
+      if (canCheckpoint) {
+        checkpoint = transaction.checkpoint();
+      }
 
       this._renderedComponent.unmountComponent(true);
-      transaction.rollback(checkpoint);
+
+      if (canCheckpoint) {
+        transaction.rollback(checkpoint);
+      }
 
       // Try again - we've informed the component about the error, so they can render an error message this time.
       // If this throws again, the error will bubble up (and can be caught by a higher error boundary).