From 07b1da89642fa9939e86488825b0476411babfe6 Mon Sep 17 00:00:00 2001 From: Brian Vaughn Date: Mon, 2 Oct 2017 16:54:40 -0700 Subject: [PATCH] Removed PooledClass (and tests) (#11053) --- scripts/rollup/packaging.js | 2 - src/renderers/native/PooledClass.js | 121 ------------------ .../native/__tests__/PooledClass-test.js | 117 ----------------- 3 files changed, 240 deletions(-) delete mode 100644 src/renderers/native/PooledClass.js delete mode 100644 src/renderers/native/__tests__/PooledClass-test.js diff --git a/scripts/rollup/packaging.js b/scripts/rollup/packaging.js index 0786579162..36f14a69fd 100644 --- a/scripts/rollup/packaging.js +++ b/scripts/rollup/packaging.js @@ -24,8 +24,6 @@ const facebookWWWSrcDependencies = [ // these files need to be copied to the react-native build const reactNativeSrcDependencies = [ - // TODO: copy this to RN repository and delete from React - 'src/renderers/native/PooledClass.js', 'src/renderers/shared/fiber/isomorphic/ReactTypes.js', 'src/renderers/native/ReactNativeTypes.js', ]; diff --git a/src/renderers/native/PooledClass.js b/src/renderers/native/PooledClass.js deleted file mode 100644 index ad5d874baa..0000000000 --- a/src/renderers/native/PooledClass.js +++ /dev/null @@ -1,121 +0,0 @@ -/** - * Copyright (c) 2013-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - * - * @providesModule PooledClass - * @flow - */ - -'use strict'; - -var invariant = require('fbjs/lib/invariant'); - -/** - * Static poolers. Several custom versions for each potential number of - * arguments. A completely generic pooler is easy to implement, but would - * require accessing the `arguments` object. In each of these, `this` refers to - * the Class itself, not an instance. If any others are needed, simply add them - * here, or in their own files. - */ -var oneArgumentPooler = function(copyFieldsFrom) { - var Klass = this; - if (Klass.instancePool.length) { - var instance = Klass.instancePool.pop(); - Klass.call(instance, copyFieldsFrom); - return instance; - } else { - return new Klass(copyFieldsFrom); - } -}; - -var twoArgumentPooler = function(a1, a2) { - var Klass = this; - if (Klass.instancePool.length) { - var instance = Klass.instancePool.pop(); - Klass.call(instance, a1, a2); - return instance; - } else { - return new Klass(a1, a2); - } -}; - -var threeArgumentPooler = function(a1, a2, a3) { - var Klass = this; - if (Klass.instancePool.length) { - var instance = Klass.instancePool.pop(); - Klass.call(instance, a1, a2, a3); - return instance; - } else { - return new Klass(a1, a2, a3); - } -}; - -var fourArgumentPooler = function(a1, a2, a3, a4) { - var Klass = this; - if (Klass.instancePool.length) { - var instance = Klass.instancePool.pop(); - Klass.call(instance, a1, a2, a3, a4); - return instance; - } else { - return new Klass(a1, a2, a3, a4); - } -}; - -var standardReleaser = function(instance) { - var Klass = this; - invariant( - instance instanceof Klass, - 'Trying to release an instance into a pool of a different type.', - ); - instance.destructor(); - if (Klass.instancePool.length < Klass.poolSize) { - Klass.instancePool.push(instance); - } -}; - -var DEFAULT_POOL_SIZE = 10; -var DEFAULT_POOLER = oneArgumentPooler; - -type Pooler = any; - -/** - * Augments `CopyConstructor` to be a poolable class, augmenting only the class - * itself (statically) not adding any prototypical fields. Any CopyConstructor - * you give this may have a `poolSize` property, and will look for a - * prototypical `destructor` on instances. - * - * @param {Function} CopyConstructor Constructor that can be used to reset. - * @param {Function} pooler Customizable pooler. - */ -var addPoolingTo = function( - CopyConstructor: Class, - pooler: Pooler, -): Class & { - getPooled( - ...args: $ReadOnlyArray - ): /* arguments of the constructor */ T, - release(instance: mixed): void, -} { - // Casting as any so that flow ignores the actual implementation and trusts - // it to match the type we declared - var NewKlass = (CopyConstructor: any); - NewKlass.instancePool = []; - NewKlass.getPooled = pooler || DEFAULT_POOLER; - if (!NewKlass.poolSize) { - NewKlass.poolSize = DEFAULT_POOL_SIZE; - } - NewKlass.release = standardReleaser; - return NewKlass; -}; - -var PooledClass = { - addPoolingTo: addPoolingTo, - oneArgumentPooler: (oneArgumentPooler: Pooler), - twoArgumentPooler: (twoArgumentPooler: Pooler), - threeArgumentPooler: (threeArgumentPooler: Pooler), - fourArgumentPooler: (fourArgumentPooler: Pooler), -}; - -module.exports = PooledClass; diff --git a/src/renderers/native/__tests__/PooledClass-test.js b/src/renderers/native/__tests__/PooledClass-test.js deleted file mode 100644 index 4a1327eadb..0000000000 --- a/src/renderers/native/__tests__/PooledClass-test.js +++ /dev/null @@ -1,117 +0,0 @@ -/** - * Copyright (c) 2014-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - * - * @emails react-core - */ - -'use strict'; - -var PooledClass; -var PoolableClass; - -describe('Pooled class', () => { - beforeEach(() => { - PooledClass = require('PooledClass'); - PoolableClass = function() {}; - PoolableClass.prototype.destructor = function() {}; - PooledClass.addPoolingTo(PoolableClass); - }); - - it('should initialize a pool correctly', () => { - expect(PoolableClass.instancePool).toBeDefined(); - }); - - it('should return a new instance when the pool is empty', () => { - var instance = PoolableClass.getPooled(); - expect(instance instanceof PoolableClass).toBe(true); - }); - - it('should return the instance back into the pool when it gets released', () => { - var instance = PoolableClass.getPooled(); - PoolableClass.release(instance); - expect(PoolableClass.instancePool.length).toBe(1); - expect(PoolableClass.instancePool[0]).toBe(instance); - }); - - it('should return an old instance if available in the pool', () => { - var instance = PoolableClass.getPooled(); - PoolableClass.release(instance); - var instance2 = PoolableClass.getPooled(); - expect(instance).toBe(instance2); - }); - - it('should call the destructor when instance gets released', () => { - var log = []; - var PoolableClassWithDestructor = function() {}; - PoolableClassWithDestructor.prototype.destructor = function() { - log.push('released'); - }; - PooledClass.addPoolingTo(PoolableClassWithDestructor); - var instance = PoolableClassWithDestructor.getPooled(); - PoolableClassWithDestructor.release(instance); - expect(log).toEqual(['released']); - }); - - it('should accept poolers with different arguments', () => { - var log = []; - var PoolableClassWithMultiArguments = function(a, b) { - log.push(a, b); - }; - PoolableClassWithMultiArguments.prototype.destructor = function() {}; - PooledClass.addPoolingTo( - PoolableClassWithMultiArguments, - PooledClass.twoArgumentPooler, - ); - PoolableClassWithMultiArguments.getPooled('a', 'b', 'c'); - expect(log).toEqual(['a', 'b']); - }); - - it('should call a new constructor with arguments', () => { - var log = []; - var PoolableClassWithOneArgument = function(a) { - log.push(a); - }; - PoolableClassWithOneArgument.prototype.destructor = function() {}; - PooledClass.addPoolingTo(PoolableClassWithOneArgument); - PoolableClassWithOneArgument.getPooled('new'); - expect(log).toEqual(['new']); - }); - - it('should call an old constructor with arguments', () => { - var log = []; - var PoolableClassWithOneArgument = function(a) { - log.push(a); - }; - PoolableClassWithOneArgument.prototype.destructor = function() {}; - PooledClass.addPoolingTo(PoolableClassWithOneArgument); - var instance = PoolableClassWithOneArgument.getPooled('new'); - PoolableClassWithOneArgument.release(instance); - PoolableClassWithOneArgument.getPooled('old'); - expect(log).toEqual(['new', 'old']); - }); - - it('should throw when the class releases an instance of a different type', () => { - var RandomClass = function() {}; - RandomClass.prototype.destructor = function() {}; - PooledClass.addPoolingTo(RandomClass); - var randomInstance = RandomClass.getPooled(); - PoolableClass.getPooled(); - expect(function() { - PoolableClass.release(randomInstance); - }).toThrowError( - 'Trying to release an instance into a pool of a different type.', - ); - }); - - it('should throw if no destructor is defined', () => { - var ImmortalClass = function() {}; - PooledClass.addPoolingTo(ImmortalClass); - var inst = ImmortalClass.getPooled(); - expect(function() { - ImmortalClass.release(inst); - }).toThrow(); - }); -});