Revert "Switch to parent-based context. Fixes facebook#2112."

This reverts commit 7d44917.

Author: jimfb

src/classic/element/ReactElement.js

@@ -99,6 +99,10 @@ var ReactElement = function(type, key, ref, owner, context, props) {
   // Record the component responsible for creating this element.
   this._owner = owner;
 
+  // TODO: Deprecate withContext, and then the context becomes accessible
+  // through the owner.
+  this._context = context;
+
   if (__DEV__) {
     // The validation flag and props are currently mutative. We put them on
     // an external backing store so that we can freeze the whole object.

src/classic/element/__tests__/ReactElement-test.js

@@ -86,6 +86,30 @@ describe('ReactElement', function() {
     expect(element.props).toEqual({foo:'56'});
   });
 
+  it('preserves the legacy context on the element', function() {
+    var Component = React.createFactory(ComponentClass);
+    var element;
+
+    var Wrapper = React.createClass({
+      childContextTypes: {
+        foo: React.PropTypes.string
+      },
+      getChildContext: function() {
+        return {foo: 'bar'};
+      },
+      render: function() {
+        element = Component();
+        return element;
+      }
+    });
+
+    ReactTestUtils.renderIntoDocument(
+      React.createElement(Wrapper)
+    );
+
+    expect(element._context).toEqual({foo: 'bar'});
+  });
+
   it('preserves the owner on the element', function() {
     var Component = React.createFactory(ComponentClass);
     var element;

src/core/ReactCompositeComponent.js

@@ -125,7 +125,7 @@ var ReactCompositeComponentMixin = {
     this._rootNodeID = rootID;
 
     var publicProps = this._processProps(this._currentElement.props);
-    var publicContext = this._processContext(context);
+    var publicContext = this._processContext(this._currentElement._context);
 
     var Component = ReactNativeComponent.getComponentClassForElement(
       this._currentElement
@@ -158,6 +158,10 @@ var ReactCompositeComponentMixin = {
     // Store a reference from the instance back to the internal representation
     ReactInstanceMap.set(inst, this);
 
+    if (__DEV__) {
+      this._warnIfContextsDiffer(this._currentElement._context, context);
+    }
+
     if (__DEV__) {
       // Since plain JS classes are defined without any special initialization
       // logic, we can not catch common errors early. Therefore, we have to
@@ -533,6 +537,30 @@ var ReactCompositeComponentMixin = {
     }
   },
 
+  /**
+   * Compare two contexts, warning if they are different
+   * TODO: Remove this check when owner-context is removed
+   */
+   _warnIfContextsDiffer: function(ownerBasedContext, parentBasedContext) {
+    ownerBasedContext = this._maskContext(ownerBasedContext);
+    parentBasedContext = this._maskContext(parentBasedContext);
+    var parentKeys = Object.keys(parentBasedContext).sort();
+    var displayName = this.getName() || 'ReactCompositeComponent';
+    for (var i = 0; i < parentKeys.length; i++) {
+      var key = parentKeys[i];
+      warning(
+        ownerBasedContext[key] === parentBasedContext[key],
+        'owner-based and parent-based contexts differ '  +
+        '(values: `%s` vs `%s`) for key (%s) while mounting %s ' +
+        '(see: http://fb.me/react-context-by-parent)',
+        ownerBasedContext[key],
+        parentBasedContext[key],
+        key,
+        displayName
+      );
+    }
+  },
+
   /**
    * Perform an update to a mounted component. The componentWillReceiveProps and
    * shouldComponentUpdate methods are called, then (assuming the update isn't
@@ -562,9 +590,18 @@ var ReactCompositeComponentMixin = {
 
     // Distinguish between a props update versus a simple state update
     if (prevParentElement !== nextParentElement) {
-      nextContext = this._processContext(nextUnmaskedContext);
+      nextContext = this._processContext(nextParentElement._context);
       nextProps = this._processProps(nextParentElement.props);
 
+      if (__DEV__) {
+        if (nextUnmaskedContext != null) {
+          this._warnIfContextsDiffer(
+            nextParentElement._context,
+            nextUnmaskedContext
+          );
+        }
+      }
+
       // An update here will schedule an update but immediately set
       // _pendingStateQueue which will ensure that any state updates gets
       // immediately reconciled instead of waiting for the next batch.

src/core/ReactContext.js

@@ -11,7 +11,11 @@
 
 'use strict';
 
+var assign = require('Object.assign');
 var emptyObject = require('emptyObject');
+var warning = require('warning');
+
+var didWarn = false;
 
 /**
  * Keeps track of the current context.
@@ -25,7 +29,45 @@ var ReactContext = {
    * @internal
    * @type {object}
    */
-  current: emptyObject
+  current: emptyObject,
+
+  /**
+   * Temporarily extends the current context while executing scopedCallback.
+   *
+   * A typical use case might look like
+   *
+   *  render: function() {
+   *    var children = ReactContext.withContext({foo: 'foo'}, () => (
+   *
+   *    ));
+   *    return <div>{children}</div>;
+   *  }
+   *
+   * @param {object} newContext New context to merge into the existing context
+   * @param {function} scopedCallback Callback to run with the new context
+   * @return {ReactComponent|array<ReactComponent>}
+   */
+  withContext: function(newContext, scopedCallback) {
+    if (__DEV__) {
+      warning(
+        didWarn,
+        'withContext is deprecated and will be removed in a future version. ' +
+        'Use a wrapper component with getChildContext instead.'
+      );
+
+      didWarn = true;
+    }
+
+    var result;
+    var previousContext = ReactContext.current;
+    ReactContext.current = assign({}, previousContext, newContext);
+    try {
+      result = scopedCallback();
+    } finally {
+      ReactContext.current = previousContext;
+    }
+    return result;
+  }
 
 };