Replace DeviceManager::GetDeviceChanges with a client interface.

third_party/WebKit/LayoutTests/usb/resources/usb-helpers.js

 'use strict';
 
 function assertRejectsWithError(promise, name, message) {
   return promise.then(() => {
     assert_unreached('expected promise to reject with ' + name);
   }, error => {
     assert_equals(error.name, name);
     if (message !== undefined)
       assert_equals(error.message, message);
   });
@@ skipping 307 matching lines @@
             status: device.TransferStatus.OK
           };
         }
         return Promise.resolve({ packets: packets });
       }
     };
 
     class MockDeviceManager {
       constructor() {
         this.mockDevices_ = new Map();
-        this.addedDevices_ = [];
-        this.removedDevices_ = [];
-        this.deviceChangePromiseResolvers_ = [];
         this.deviceCloseHandler_ = null;
+        this.client_ = null;
       }
 
       bindToPipe(pipe) {
         this.stub_ = connection.bindHandleToStub(
             pipe, deviceManager.DeviceManager);
         bindings.StubBindings(this.stub_).delegate = this;
       }
 
       reset() {
         this.mockDevices_.forEach(device => {
           for (var stub of device.stubs)
             bindings.StubBindings(stub).close();
-          this.removedDevices_.push(device.info);
         });
         this.mockDevices_.clear();
-        this.maybeResolveDeviceChangePromise();
       }
 
       addMockDevice(info) {
         let device = {
           info: info,
           stubs: []
         };
         this.mockDevices_.set(info.guid, device);
-        this.addedDevices_.push(info);
-        this.maybeResolveDeviceChangePromise();
+        if (this.client_)
+          this.client_.onDeviceAdded(info);
       }
 
       removeMockDevice(info) {
         let device = this.mockDevices_.get(info.guid);
         for (var stub of device.stubs)
           bindings.StubBindings(stub).close();
         this.mockDevices_.delete(info.guid);
-        this.removedDevices_.push(info);
-        this.maybeResolveDeviceChangePromise();
+        if (this.client_)
+          this.client_.onDeviceRemoved(info);
       }
 
       setDeviceCloseHandler(handler) {
         this.deviceCloseHandler_ = handler;
       }
 
       getDevices(options) {
         let devices = [];
         this.mockDevices_.forEach(device => {
           devices.push(device.info);
         });
         return Promise.resolve({ results: devices });
       }
 
-      getDeviceChanges() {
-        let promise = new Promise((resolve, reject) => {
-          this.deviceChangePromiseResolvers_.push(resolve);
-        });
-        this.maybeResolveDeviceChangePromise();
-        return promise;
-      }
-
-      maybeResolveDeviceChangePromise() {
-        if (this.addedDevices_.length == 0 &&
-            this.removedDevices_.length == 0) {
-          return;
-        }
-
-        let resolve = this.deviceChangePromiseResolvers_.shift();
-        if (resolve === undefined)
-          return;
-
-        resolve({
-          changes: {
-            devices_added: this.addedDevices_,
-            devices_removed: this.removedDevices_
-          }
-        });
-        this.addedDevices_ = [];
-        this.removedDevices_ = [];
-      }
-
       getDevice(guid, stub) {
         let device = this.mockDevices_.get(guid);
         if (device === undefined) {
           bindings.StubBindings(stub).close();
         } else {
           var mock = new MockDevice(device.info);
           bindings.StubBindings(stub).delegate = mock;
           bindings.StubBindings(stub).connectionErrorHandler = () => {
             if (this.deviceCloseHandler_)
               this.deviceCloseHandler_(device.info);
           };
           device.stubs.push(stub);
         }
       }
+
+      setClient(client) {
+        this.client_ = client;
+      }
     }
 
     class MockChooserService {
       constructor() {
         this.chosenDevice_ = null;
       }
 
       bindToPipe(pipe) {
         this.stub_ = connection.bindHandleToStub(
             pipe, chooserService.ChooserService);
@@ skipping 37 matching lines @@
 }
 
 function usb_test(func, name, properties) {
   mojo_test(mojo => usbMocks(mojo).then(usb => {
     let result = Promise.resolve(func(usb));
     let cleanUp = () => usb.mockDeviceManager.reset();
     result.then(cleanUp, cleanUp);
     return result;
   }), name, properties);
 }