diff --git a/packages/container/lib/container.js b/packages/container/lib/container.js
index b49bc7817e4..07c5e8342b9 100644
--- a/packages/container/lib/container.js
+++ b/packages/container/lib/container.js
@@ -32,7 +32,6 @@ export default function Container(registry, options) {
   this.registry        = registry;
   this.owner           = options && options.owner ? options.owner : null;
   this.cache           = dictionary(options && options.cache ? options.cache : null);
-  this.factoryCache    = dictionary(options && options.factoryCache ? options.factoryCache : null);
   this.factoryManagerCache = dictionary(options && options.factoryManagerCache ? options.factoryManagerCache : null);
   this.validationCache = dictionary(options && options.validationCache ? options.validationCache : null);
   this[CONTAINER_OVERRIDE] = undefined;
@@ -53,12 +52,6 @@ Container.prototype = {
    @type InheritingDict
    */
 
-  /**
-   @private
-   @property factoryCache
-   @type InheritingDict
-   */
-
   /**
    @private
    @property validationCache
@@ -102,23 +95,6 @@ Container.prototype = {
     return lookup(this, this.registry.normalize(fullName), options);
   },
 
-  /**
-   Given a fullName, return the corresponding factory.
-    @private
-   @method lookupFactory
-   @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
-   @return {any}
-   */
-  lookupFactory(fullName, options) {
-    assert('fullName must be a proper full name', this.registry.validateFullName(fullName));
-
-    deprecate('Using "_lookupFactory" is deprecated. Please use container.factoryFor instead.', false, { id: 'container-lookupFactory', until: '2.13.0', url: 'http://emberjs.com/deprecations/v2.x/#toc_migrating-from-_lookupfactory-to-factoryfor' });
-
-    return deprecatedFactoryFor(this, this.registry.normalize(fullName), options);
-  },
-
   /**
    A depth first traversal, destroying the container, its descendant containers and all
    their managed objects.
@@ -190,6 +166,10 @@ Container.prototype = {
       return;
     }
 
+    if (DEBUG && factory && typeof factory._onLookup === 'function') {
+      factory._onLookup(fullName);
+    }
+
     let manager = new FactoryManager(this, factory, fullName, normalizedName);
 
     if (DEBUG) {
@@ -348,61 +328,6 @@ function buildInjections() /* container, ...injections */{
   return hash;
 }
 
-function deprecatedFactoryFor(container, fullName, options = {}) {
-  let registry = container.registry;
-
-  if (options.source) {
-    fullName = registry.expandLocalLookup(fullName, options);
-    // if expandLocalLookup returns falsey, we do not support local lookup
-    if (!fullName) {
-      return;
-    }
-  }
-
-  let cache = container.factoryCache;
-  if (cache[fullName]) {
-    return cache[fullName];
-  }
-  let factory = registry.resolve(fullName);
-  if (factory === undefined) {
-    return;
-  }
-
-  let type = fullName.split(':')[0];
-  if (!factory || typeof factory.extend !== 'function' || !ENV.MODEL_FACTORY_INJECTIONS && type === 'model') {
-    if (factory && typeof factory._onLookup === 'function') {
-      factory._onLookup(fullName);
-    }
-
-    // TODO: think about a 'safe' merge style extension
-    // for now just fallback to create time injection
-    cache[fullName] = factory;
-    return factory;
-  } else {
-    let injections = injectionsFor(container, fullName);
-    let factoryInjections = factoryInjectionsFor(container, fullName);
-    let cacheable = !areInjectionsDynamic(injections) && !areInjectionsDynamic(factoryInjections);
-
-    factoryInjections[NAME_KEY] = registry.makeToString(factory, fullName);
-    injections._debugContainerKey = fullName;
-    setOwner(injections, container.owner);
-
-    let injectedFactory = factory.extend(injections);
-
-    injectedFactory.reopenClass(factoryInjections);
-
-    if (factory && typeof factory._onLookup === 'function') {
-      factory._onLookup(fullName);
-    }
-
-    if (cacheable) {
-      cache[fullName] = injectedFactory;
-    }
-
-    return injectedFactory;
-  }
-}
-
 function injectionsFor(container, fullName) {
   let registry = container.registry;
   let splitName = fullName.split(':');
@@ -413,74 +338,6 @@ function injectionsFor(container, fullName) {
   return injections;
 }
 
-function instantiate(factory, props, container, fullName) {
-  let lazyInjections, validationCache;
-
-  props = props || {};
-
-  if (container.registry.getOption(fullName, 'instantiate') === false) {
-    return factory;
-  }
-
-  if (factory) {
-    if (typeof factory.create !== 'function') {
-      throw new Error(`Failed to create an instance of '${fullName}'. Most likely an improperly defined class or` + ` an invalid module export.`);
-    }
-
-    validationCache = container.validationCache;
-
-    if (DEBUG) {
-      // Ensure that all lazy injections are valid at instantiation time
-      if (!validationCache[fullName] && typeof factory._lazyInjections === 'function') {
-        lazyInjections = factory._lazyInjections();
-        lazyInjections = container.registry.normalizeInjectionsHash(lazyInjections);
-
-        container.registry.validateInjections(lazyInjections);
-      }
-    }
-
-    validationCache[fullName] = true;
-
-    let obj;
-
-    if (typeof factory.extend === 'function') {
-      // assume the factory was extendable and is already injected
-      obj = factory.create(props);
-    } else {
-      // assume the factory was extendable
-      // to create time injections
-      // TODO: support new'ing for instantiation and merge injections for pure JS Functions
-      let injections = injectionsFor(container, fullName);
-      injections._debugContainerKey = fullName;
-
-      // Ensure that a container is available to an object during instantiation.
-      // TODO - remove when Ember reaches v3.0.0
-      // This "fake" container will be replaced after instantiation with a
-      // property that raises deprecations every time it is accessed.
-      injections.container = container._fakeContainerToInject;
-      obj = factory.create(assign({}, injections, props));
-
-      // TODO - remove when Ember reaches v3.0.0
-      if (!Object.isFrozen(obj)) {
-        injectDeprecatedContainer(obj, container);
-      }
-    }
-
-    return obj;
-  }
-}
-
-function factoryInjectionsFor(container, fullName) {
-  let registry = container.registry;
-  let splitName = fullName.split(':');
-  let type = splitName[0];
-
-  let factoryInjections = buildInjections(container, registry.getFactoryTypeInjections(type), registry.getFactoryInjections(fullName));
-  factoryInjections._debugContainerKey = fullName;
-
-  return factoryInjections;
-}
-
 function destroyDestroyables(container) {
   let cache = container.cache;
   let keys = Object.keys(cache);
@@ -503,7 +360,7 @@ function resetCache(container) {
 function resetMember(container, fullName) {
   let member = container.cache[fullName];
 
-  delete container.factoryCache[fullName];
+  delete container.factoryManagerCache[fullName];
 
   if (member) {
     delete container.cache[fullName];
@@ -514,18 +371,6 @@ function resetMember(container, fullName) {
   }
 }
 
-class DeprecatedFactoryManager {
-  constructor(container, factory, fullName) {
-    this.container = container;
-    this.class = factory;
-    this.fullName = fullName;
-  }
-
-  create(props = {}) {
-    return instantiate(this.class, props, this.container, this.fullName);
-  }
-}
-
 class FactoryManager {
   constructor(container, factory, fullName, normalizedName) {
     this.container = container;
diff --git a/packages/container/lib/registry.js b/packages/container/lib/registry.js
index 3d9ba5016bd..ae62b7b791a 100644
--- a/packages/container/lib/registry.js
+++ b/packages/container/lib/registry.js
@@ -32,8 +32,6 @@ export default function Registry(options) {
 
   this._typeInjections        = dictionary(null);
   this._injections            = dictionary(null);
-  this._factoryTypeInjections = dictionary(null);
-  this._factoryInjections     = dictionary(null);
 
   this._localLookupCache      = Object.create(null);
   this._normalizeCache        = dictionary(null);
@@ -86,22 +84,6 @@ Registry.prototype = {
    */
   _injections: null,
 
-  /**
-   @private
-
-   @property _factoryTypeInjections
-   @type InheritingDict
-   */
-  _factoryTypeInjections: null,
-
-  /**
-   @private
-
-   @property _factoryInjections
-   @type InheritingDict
-   */
-  _factoryInjections: null,
-
   /**
    @private
 
@@ -549,115 +531,6 @@ Registry.prototype = {
     });
   },
 
-
-  /**
-   Used only via `factoryInjection`.
-
-   Provides a specialized form of injection, specifically enabling
-   all factory of one type to be injected with a reference to another
-   object.
-
-   For example, provided each factory of type `model` needed a `store`.
-   one would do the following:
-
-   ```javascript
-   let registry = new Registry();
-
-   registry.register('store:main', SomeStore);
-
-   registry.factoryTypeInjection('model', 'store', 'store:main');
-
-   let store = registry.lookup('store:main');
-   let UserFactory = registry.lookupFactory('model:user');
-
-   UserFactory.store instanceof SomeStore; //=> true
-   ```
-
-   @private
-   @method factoryTypeInjection
-   @param {String} type
-   @param {String} property
-   @param {String} fullName
-   */
-  factoryTypeInjection(type, property, fullName) {
-    let injections = this._factoryTypeInjections[type] ||
-                     (this._factoryTypeInjections[type] = []);
-
-    injections.push({
-      property: property,
-      fullName: this.normalize(fullName)
-    });
-  },
-
-  /**
-   Defines factory injection rules.
-
-   Similar to regular injection rules, but are run against factories, via
-   `Registry#lookupFactory`.
-
-   These rules are used to inject objects onto factories when they
-   are looked up.
-
-   Two forms of injections are possible:
-
-   * Injecting one fullName on another fullName
-   * Injecting one fullName on a type
-
-   Example:
-
-   ```javascript
-   let registry = new Registry();
-   let container = registry.container();
-
-   registry.register('store:main', Store);
-   registry.register('store:secondary', OtherStore);
-   registry.register('model:user', User);
-   registry.register('model:post', Post);
-
-   // injecting one fullName on another type
-   registry.factoryInjection('model', 'store', 'store:main');
-
-   // injecting one fullName on another fullName
-   registry.factoryInjection('model:post', 'secondaryStore', 'store:secondary');
-
-   let UserFactory = container.lookupFactory('model:user');
-   let PostFactory = container.lookupFactory('model:post');
-   let store = container.lookup('store:main');
-
-   UserFactory.store instanceof Store; //=> true
-   UserFactory.secondaryStore instanceof OtherStore; //=> false
-
-   PostFactory.store instanceof Store; //=> true
-   PostFactory.secondaryStore instanceof OtherStore; //=> true
-
-   // and both models share the same source instance
-   UserFactory.store === PostFactory.store; //=> true
-   ```
-
-   @private
-   @method factoryInjection
-   @param {String} factoryName
-   @param {String} property
-   @param {String} injectionName
-   */
-  factoryInjection(fullName, property, injectionName) {
-    let normalizedName = this.normalize(fullName);
-    let normalizedInjectionName = this.normalize(injectionName);
-
-    this.validateFullName(injectionName);
-
-    if (fullName.indexOf(':') === -1) {
-      return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName);
-    }
-
-    let injections = this._factoryInjections[normalizedName] || (this._factoryInjections[normalizedName] = []);
-
-    injections.push({
-      property: property,
-      fullName: normalizedInjectionName
-    });
-  },
-
   /**
    @private
    @method knownForType
@@ -743,22 +616,6 @@ Registry.prototype = {
       injections = injections.concat(this.fallback.getTypeInjections(type));
     }
     return injections;
-  },
-
-  getFactoryInjections(fullName) {
-    let injections = this._factoryInjections[fullName] || [];
-    if (this.fallback) {
-      injections = injections.concat(this.fallback.getFactoryInjections(fullName));
-    }
-    return injections;
-  },
-
-  getFactoryTypeInjections(type) {
-    let injections = this._factoryTypeInjections[type] || [];
-    if (this.fallback) {
-      injections = injections.concat(this.fallback.getFactoryTypeInjections(type));
-    }
-    return injections;
   }
 };
 
diff --git a/packages/container/tests/container_test.js b/packages/container/tests/container_test.js
index db5c2049030..5aceb142c9a 100644
--- a/packages/container/tests/container_test.js
+++ b/packages/container/tests/container_test.js
@@ -15,15 +15,6 @@ QUnit.module('Container', {
   }
 });
 
-function lookupFactory(name, container, options) {
-  let factory;
-  expectDeprecation(() => {
-    factory = container.lookupFactory(name, options);
-  }, 'Using "_lookupFactory" is deprecated. Please use container.factoryFor instead.');
-
-  return factory;
-}
-
 QUnit.test('A registered factory returns the same instance each time', function() {
   let registry = new Registry();
   let container = registry.container();
@@ -38,42 +29,6 @@ QUnit.test('A registered factory returns the same instance each time', function(
   equal(postController, container.lookup('controller:post'));
 });
 
-QUnit.test('A registered factory is returned from lookupFactory', function() {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-
-  registry.register('controller:post', PostController);
-
-  let PostControllerFactory = lookupFactory('controller:post', container);
-
-  ok(PostControllerFactory, 'factory is returned');
-  ok(PostControllerFactory.create() instanceof  PostController, 'The return of factory.create is an instance of PostController');
-});
-
-QUnit.test('A registered factory is returned from lookupFactory is the same factory each time', function() {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-
-  registry.register('controller:post', PostController);
-
-  let Post1 = lookupFactory('controller:post', container);
-  let Post2 = lookupFactory('controller:post', container);
-
-  deepEqual(Post1, Post2, 'The return of lookupFactory is always the same');
-});
-
-QUnit.test('A factory returned from lookupFactory has a debugkey', function() {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-
-  registry.register('controller:post', PostController);
-  let PostFactory = lookupFactory('controller:post', container);
-  equal(PostFactory._debugContainerKey, 'controller:post', 'factory instance receives _debugContainerKey');
-});
-
 QUnit.test('uses create time injections if factory has no extend', function() {
   let registry = new Registry();
   let container = registry.container();
@@ -91,20 +46,6 @@ QUnit.test('uses create time injections if factory has no extend', function() {
   ok(postController.apple instanceof AppleController, 'instance receives an apple of instance AppleController');
 });
 
-QUnit.test('The descendants of a factory returned from lookupFactory have a container and debugkey', function() {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-  let instance;
-
-  registry.register('controller:post', PostController);
-  instance = lookupFactory('controller:post', container).create();
-
-  equal(instance._debugContainerKey, 'controller:post', 'factory instance receives _debugContainerKey');
-
-  ok(instance instanceof PostController, 'factory instance is instance of factory');
-});
-
 QUnit.test('A registered factory returns a fresh instance if singleton: false is passed as an option', function() {
   let registry = new Registry();
   let container = registry.container();
@@ -184,28 +125,6 @@ QUnit.test('A factory with both type and individual injections', function() {
   equal(postController.router, router);
 });
 
-QUnit.test('A factory with both type and individual factoryInjections', function() {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-  let Store = factory();
-  let Router = factory();
-
-  registry.register('controller:post', PostController);
-  registry.register('store:main', Store);
-  registry.register('router:main', Router);
-
-  registry.factoryInjection('controller:post', 'store', 'store:main');
-  registry.factoryTypeInjection('controller', 'router', 'router:main');
-
-  let PostControllerFactory = lookupFactory('controller:post', container);
-  let store = container.lookup('store:main');
-  let router = container.lookup('router:main');
-
-  equal(PostControllerFactory.store, store, 'PostControllerFactory has the instance of store');
-  equal(PostControllerFactory.router, router, 'PostControllerFactory has the route instance');
-});
-
 QUnit.test('A non-singleton instance is never cached', function() {
   let registry = new Registry();
   let container = registry.container();
@@ -356,9 +275,10 @@ QUnit.test('The container normalizes names when looking factory up', function()
   };
 
   registry.register('controller:post', PostController);
-  let fact = lookupFactory('controller:normalized', container);
+  let fact = container.factoryFor('controller:normalized');
 
-  equal(fact.toString() === PostController.extend().toString(), true, 'Normalizes the name when looking factory up');
+  let factInstance = fact.create();
+  ok(factInstance instanceof PostController, 'Normalizes the name');
 });
 
 QUnit.test('Options can be registered that should be applied to a given factory', function() {
@@ -436,10 +356,10 @@ QUnit.test('Factory resolves are cached', function() {
   };
 
   deepEqual(resolveWasCalled, []);
-  lookupFactory('controller:post', container);
+  container.factoryFor('controller:post');
   deepEqual(resolveWasCalled, ['controller:post']);
 
-  lookupFactory('controller:post', container);
+  container.factoryFor('controller:post');
   deepEqual(resolveWasCalled, ['controller:post']);
 });
 
@@ -454,10 +374,10 @@ QUnit.test('factory for non extendables (MODEL) resolves are cached', function()
   };
 
   deepEqual(resolveWasCalled, []);
-  lookupFactory('model:post', container);
+  container.factoryFor('model:post');
   deepEqual(resolveWasCalled, ['model:post']);
 
-  lookupFactory('model:post', container);
+  container.factoryFor('model:post');
   deepEqual(resolveWasCalled, ['model:post']);
 });
 
@@ -473,33 +393,13 @@ QUnit.test('factory for non extendables resolves are cached', function() {
   };
 
   deepEqual(resolveWasCalled, []);
-  lookupFactory('foo:post', container);
+  container.factoryFor('foo:post');
   deepEqual(resolveWasCalled, ['foo:post']);
 
-  lookupFactory('foo:post', container);
+  container.factoryFor('foo:post');
   deepEqual(resolveWasCalled, ['foo:post']);
 });
 
-QUnit.test('The `_onLookup` hook is called on factories when looked up the first time', function() {
-  expect(4); // 2 are from expectDeprecation in `lookupFactory`
-
-  let registry = new Registry();
-  let container = registry.container();
-  let Apple = factory();
-
-  Apple.reopenClass({
-    _onLookup(fullName) {
-      equal(fullName, 'apple:main', 'calls lazy injection method with the lookup full name');
-      equal(this, Apple, 'calls lazy injection method in the factory context');
-    }
-  });
-
-  registry.register('apple:main', Apple);
-
-  lookupFactory('apple:main', container);
-  lookupFactory('apple:main', container);
-});
-
 QUnit.test('A factory\'s lazy injections are validated when first instantiated', function() {
   let registry = new Registry();
   let container = registry.container();
@@ -552,26 +452,6 @@ QUnit.test('An object with its owner pre-set should be returned from ownerInject
   equal(result[OWNER], owner, 'owner is properly included');
 });
 
-QUnit.test('lookupFactory passes options through to expandlocallookup', function(assert) {
-  let registry = new Registry();
-  let container = registry.container();
-  let PostController = factory();
-
-  registry.register('controller:post', PostController);
-
-  registry.expandLocalLookup = function(fullName, options) {
-    assert.ok(true, 'expandLocalLookup was called');
-    assert.equal(fullName, 'foo:bar');
-    assert.deepEqual(options, { source: 'baz:qux' });
-
-    return 'controller:post';
-  };
-
-  let PostControllerFactory = lookupFactory('foo:bar', container, { source: 'baz:qux' });
-
-  assert.ok(PostControllerFactory.create() instanceof  PostController, 'The return of factory.create is an instance of PostController');
-});
-
 QUnit.test('lookup passes options through to expandlocallookup', function(assert) {
   let registry = new Registry();
   let container = registry.container();
diff --git a/packages/container/tests/registry_test.js b/packages/container/tests/registry_test.js
index b5071c6b69d..dda19296718 100644
--- a/packages/container/tests/registry_test.js
+++ b/packages/container/tests/registry_test.js
@@ -436,29 +436,6 @@ QUnit.test('`getTypeInjections` includes type injections from a fallback registr
   equal(registry.getTypeInjections('model').length, 1, 'Injections from the fallback registry are merged');
 });
 
-QUnit.test('`getFactoryInjections` includes factory injections from a fallback registry', function() {
-  let fallback = new Registry();
-  let registry = new Registry({ fallback: fallback });
-
-  equal(registry.getFactoryInjections('model:user').length, 0, 'No factory injections in the primary registry');
-
-  fallback.factoryInjection('model:user', 'store', 'store:main');
-
-  equal(registry.getFactoryInjections('model:user').length, 1, 'Factory injections from the fallback registry are merged');
-});
-
-
-QUnit.test('`getFactoryTypeInjections` includes factory type injections from a fallback registry', function() {
-  let fallback = new Registry();
-  let registry = new Registry({ fallback: fallback });
-
-  equal(registry.getFactoryTypeInjections('model').length, 0, 'No factory type injections in the primary registry');
-
-  fallback.factoryInjection('model', 'store', 'store:main');
-
-  equal(registry.getFactoryTypeInjections('model').length, 1, 'Factory type injections from the fallback registry are merged');
-});
-
 QUnit.test('`knownForType` contains keys for each item of a given type', function() {
   let registry = new Registry();
 
diff --git a/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js b/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
index 67e3701f00e..80cb142c138 100644
--- a/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
+++ b/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
@@ -60,12 +60,6 @@ QUnit.test('the default resolver looks up templates in Ember.TEMPLATES', functio
   setTemplate('fooBar', fooBarTemplate);
   setTemplate('fooBar/baz', fooBarBazTemplate);
 
-  ignoreDeprecation(() => {
-    equal(locator.lookupFactory('template:foo'), fooTemplate, 'resolves template:foo');
-    equal(locator.lookupFactory('template:fooBar'), fooBarTemplate, 'resolves template:foo_bar');
-    equal(locator.lookupFactory('template:fooBar.baz'), fooBarBazTemplate, 'resolves template:foo_bar.baz');
-  });
-
   equal(locator.factoryFor('template:foo').class, fooTemplate, 'resolves template:foo');
   equal(locator.factoryFor('template:fooBar').class, fooBarTemplate, 'resolves template:foo_bar');
   equal(locator.factoryFor('template:fooBar.baz').class, fooBarBazTemplate, 'resolves template:foo_bar.baz');
@@ -88,20 +82,12 @@ QUnit.test('the default resolver looks up arbitrary types on the namespace', fun
 QUnit.test('the default resolver resolves models on the namespace', function() {
   application.Post = EmberObject.extend({});
 
-  ignoreDeprecation(() => {
-    detectEqual(application.Post, locator.lookupFactory('model:post'), 'looks up Post model on application');
-  });
-
   detectEqual(application.Post, locator.factoryFor('model:post').class, 'looks up Post model on application');
 });
 
 QUnit.test('the default resolver resolves *:main on the namespace', function() {
   application.FooBar = EmberObject.extend({});
 
-  ignoreDeprecation(() => {
-    detectEqual(application.FooBar, locator.lookupFactory('foo-bar:main'), 'looks up FooBar type without name on application');
-  });
-
   detectEqual(application.FooBar, locator.factoryFor('foo-bar:main').class, 'looks up FooBar type without name on application');
 });
 
@@ -130,16 +116,14 @@ QUnit.test('the default resolver resolves container-registered helpers via looku
   application.register('helper:shorthand', shorthandHelper);
   application.register('helper:complete', helper);
 
-  ignoreDeprecation(() => {
-    let lookedUpShorthandHelper = locator.lookupFactory('helper:shorthand');
+  let lookedUpShorthandHelper = locator.factoryFor('helper:shorthand').class;
 
-    ok(lookedUpShorthandHelper.isHelperInstance, 'shorthand helper isHelper');
+  ok(lookedUpShorthandHelper.isHelperInstance, 'shorthand helper isHelper');
 
-    let lookedUpHelper = locator.lookupFactory('helper:complete');
+  let lookedUpHelper = locator.factoryFor('helper:complete').class;
 
-    ok(lookedUpHelper.isHelperFactory, 'complete helper is factory');
-    ok(helper.detect(lookedUpHelper), 'looked up complete helper');
-  });
+  ok(lookedUpHelper.isHelperFactory, 'complete helper is factory');
+  ok(helper.detect(lookedUpHelper), 'looked up complete helper');
 });
 
 QUnit.test('the default resolver resolves helpers on the namespace', function() {
diff --git a/packages/ember-runtime/lib/system/object.js b/packages/ember-runtime/lib/system/object.js
index af808c7d961..04d699840e8 100644
--- a/packages/ember-runtime/lib/system/object.js
+++ b/packages/ember-runtime/lib/system/object.js
@@ -36,12 +36,6 @@ const EmberObject = CoreObject.extend(Observable, {
       let { factory } = meta;
 
       return factory && factory.fullName;
-    },
-
-    // we need a setter here largely to support the legacy
-    // `owner._lookupFactory` and its double extend
-    set(value) {
-      this[OVERRIDE_CONTAINER_KEY] = value;
     }
   }),
 
@@ -58,8 +52,8 @@ const EmberObject = CoreObject.extend(Observable, {
       return factory && factory.owner;
     },
 
-    // we need a setter here largely to support the legacy
-    // `owner._lookupFactory` and its double extend
+    // we need a setter here largely to support
+    // folks calling `owner.ownerInjection()` API
     set(value) {
       this[OVERRIDE_OWNER] = value;
     }
diff --git a/packages/ember-runtime/tests/controllers/controller_test.js b/packages/ember-runtime/tests/controllers/controller_test.js
index 6e6b5e5c447..8ea64577180 100644
--- a/packages/ember-runtime/tests/controllers/controller_test.js
+++ b/packages/ember-runtime/tests/controllers/controller_test.js
@@ -159,12 +159,10 @@ if (!EmberDev.runningProdBuild) {
         foo: inject.controller('bar')
       });
 
+      owner.register('controller:bar', EmberObject.extend());
       owner.register('foo:main', AnObject);
 
-      expectDeprecation(() => {
-        owner._lookupFactory('foo:main');
-      }, /Using "_lookupFactory" is deprecated. Please use container.factoryFor instead./);
-
+      owner.lookup('foo:main');
     }, /Defining an injected controller property on a non-controller is not allowed./);
   });
 }
diff --git a/packages/ember-runtime/tests/inject_test.js b/packages/ember-runtime/tests/inject_test.js
index a7289fa1d2a..91fdc25ce86 100644
--- a/packages/ember-runtime/tests/inject_test.js
+++ b/packages/ember-runtime/tests/inject_test.js
@@ -32,11 +32,11 @@ if (!EmberDev.runningProdBuild) {
     });
 
     owner.register('foo:main', AnObject);
+    owner.register('foo:bar', EmberObject.extend());
+    owner.register('foo:baz', EmberObject.extend());
 
-    expect(2);
-    expectDeprecation(() => {
-      owner._lookupFactory('foo:main');
-    }, /Using "_lookupFactory" is deprecated. Please use container.factoryFor instead./);
+    expect(1);
+    owner.lookup('foo:main');
   });
 
   QUnit.test('attempting to inject a nonexistent container key should error', function() {
diff --git a/tests/node/helpers/component-module.js b/tests/node/helpers/component-module.js
index 5699e7240e9..92264d6feec 100644
--- a/tests/node/helpers/component-module.js
+++ b/tests/node/helpers/component-module.js
@@ -64,7 +64,7 @@ function setupComponentTest() {
   module.owner.register('service:-document', new SimpleDOM.Document(), { instantiate: false });
 
   this._hasRendered = false;
-  let OutletView = module.owner._lookupFactory('view:-outlet');
+  let OutletView = module.owner.factoryFor('view:-outlet');
   var OutletTemplate = module.owner.lookup('template:-outlet');
   module.component = OutletView.create();
   this._outletState = {