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));
     }
 
-    getFrameData() {
-      return this.mock_service_.buffer_data_;
+    getFrameData(index) {

[Ken Rockot(use gerrit already), 2017/05/04 08:22:42]

It seems index is always 0, so this is just a more complicated way of doing what
was already done before (i.e. having bufferData_ etc as fields directly on the
provider.)

To be clear, I wasn't sure in my previous comments whether there was actually a
problem with that situation. I was really just asking if that was safe.

Can you please confirm whether or not multiple tests may run concurrently in a
single layout test html i.e. in the same script context?

If the answer is no, then this is safe and what you had before is cleaner. But
then I don't understand what the point of accumulating mockServiceInstances_
would be, because there should be no need for a service instance to remain alive
beyond the duration of a single test.

If the answer is yes, then accumulating mockServiceInstances_ makes sense, but
the code to track buffer data, max detected faces, etc, per test is still wrong.
And this would surprise me because it seems like it would be quite difficult to
do what you want in this sort of environment.

+      return this.mockServiceInstances_[index].bufferData_;
     }
 
-    getMaxDetectedFaces() {
-     return this.mock_service_.maxDetectedFaces_;
+    getMaxDetectedFaces(index) {
+     return this.mockServiceInstances_[index].maxDetectedFaces_;
     }
 
-    getFastMode () {
-      return this.mock_service_.fastMode_;
+    getFastMode (index) {
+      return this.mockServiceInstances_[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();
 });