ShapeDetection: Holding all of mock service to prevent GC

third_party/WebKit/LayoutTests/shapedetection/resources/mock-facedetection.js

 "use strict";
 
 let mockFaceDetectionProviderReady = define(
   'mockFaceDetectionProvider',
   ['services/shape_detection/public/interfaces/facedetection.mojom',
    'services/shape_detection/public/interfaces/facedetection_provider.mojom',
    'mojo/public/js/bindings',
    'mojo/public/js/core',
    'content/public/renderer/interfaces',
   ], (faceDetection, faceDetectionProvider, bindings, mojo, interfaces) => {
 
   class MockFaceDetectionProvider {
     constructor() {
       this.bindingSet_ = new bindings.BindingSet(
           faceDetectionProvider.FaceDetectionProvider);
 
       interfaces.addInterfaceOverrideForTesting(
           faceDetectionProvider.FaceDetectionProvider.name,
           handle => this.bindingSet_.addBinding(this, handle));
+
+      this.mockServiceInstances_ = [];
     }
 
     createFaceDetection(request, options) {
-      this.mock_service_ = new MockFaceDetection(request, options);
+      this.mockServiceInstances_.push(new MockFaceDetection(request, options));
+      this.index = this.mockServiceInstances_.length -1;

[Ken Rockot(use gerrit already), 2017/05/17 15:29:23]

You established in your previous reply that multiple tests may run concurrently
in the same context. That would make this code incorrect. i.e. it's possible for
the following sequence of events to occur:

 test1: createFaceDetection()  // index gets set to 0
 test2: createFaceDetection()  // index gets set to 1
 test1: call getFrameData()    // returns instance[1].bufferData_ instead of
instance[0].bufferData_

     }
 
     getFrameData() {
-      return this.mock_service_.buffer_data_;
+      return this.mockServiceInstances_[this.index].bufferData_;
     }
 
     getMaxDetectedFaces() {
-     return this.mock_service_.maxDetectedFaces_;
+     return this.mockServiceInstances_[this.index].maxDetectedFaces_;
     }
 
     getFastMode () {
-      return this.mock_service_.fastMode_;
+      return this.mockServiceInstances_[this.index].fastMode_;
     }
   }
 
   class MockFaceDetection {
     constructor(request, options) {
       this.maxDetectedFaces_ = options.max_detected_faces;
       this.fastMode_ = options.fast_mode;
       this.binding_ = new bindings.Binding(faceDetection.FaceDetection, this,
                                            request);
     }
 
     detect(frame_data, width, height) {
       let receivedStruct = mojo.mapBuffer(frame_data, 0, width*height*4, 0);
-      this.buffer_data_ = new Uint32Array(receivedStruct.buffer);
+      this.bufferData_ = new Uint32Array(receivedStruct.buffer);
       return Promise.resolve({
         result: {
           bounding_boxes: [
             { x : 1.0, y: 1.0, width: 100.0, height: 100.0 },
             { x : 2.0, y: 2.0, width: 200.0, height: 200.0 },
             { x : 3.0, y: 3.0, width: 300.0, height: 300.0 },
           ]
         }
       });
       mojo.unmapBuffer(receivedStruct.buffer);
     }
   }
   return new MockFaceDetectionProvider();
 });