Files.app: Start to use DeviceEventRouter.

chrome/test/data/file_manager/unit_tests/device_handler_unittest.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 'use strict';
 
 /**
  * Test target.
  * @type {DeviceHandler}
  */
 var handler;
@@ skipping 83 matching lines @@
  * Call all pending timeout functions.
  */
 function callTimeoutCallbacks() {
   while (timeoutCallbacks.length) {
     timeoutCallbacks.shift()();
   }
 }
 
 function registerTypicalDevice() {
   chrome.fileBrowserPrivate.onDeviceChanged.dispatch({
-    type: 'added',
+    type: 'scan_started',
     devicePath: '/device/path'
   });
-  assertFalse('device:/device/path' in chrome.notifications.items);
-  callTimeoutCallbacks();
+  assertTrue('device:/device/path' in chrome.notifications.items);
   assertEquals('Scanning...',
                chrome.notifications.items['device:/device/path'].message);
 }
 
 function testGoodDevice() {
   registerTypicalDevice();
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'success',
     volumeMetadata: {
       isParentDevice: true,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(0, Object.keys(chrome.notifications.items).length);
 }
 
 function testGoodDeviceWithBadParent() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: true,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertFalse(!!chrome.notifications.items['device:/device/path']);
   assertEquals(
       'DEVICE_UNKNOWN: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'success',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(0, Object.keys(chrome.notifications.items).length);
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'success',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   // Should do nothing this time.
   assertEquals(0, Object.keys(chrome.notifications.items).length);
 }
 
 function testUnsupportedDevice() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_unsupported_filesystem',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertFalse(!!chrome.notifications.items['device:/device/path']);
   assertEquals(
       'DEVICE_UNSUPPORTED: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testUnsupportedWithUnknownParent() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: true,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(
       'DEVICE_UNKNOWN: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_unsupported_filesystem',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'DEVICE_UNSUPPORTED: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testMountPartialSuccess() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'success',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(0, Object.keys(chrome.notifications.items).length);
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_unsupported_filesystem',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'MULTIPART_DEVICE_UNSUPPORTED: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testUnknown() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_unknown',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'DEVICE_UNKNOWN: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testNonASCIILabel() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       // "RA (U+30E9) BE (U+30D9) RU (U+30EB)" in Katakana letters.
       deviceLabel: '\u30E9\u30D9\u30EB'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'DEVICE_UNKNOWN: \u30E9\u30D9\u30EB',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testMulitpleFail() {
   registerTypicalDevice();
 
   // The first parent error.
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: true,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'DEVICE_UNKNOWN: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 
   // The first child error that replaces the parent error.
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'DEVICE_UNKNOWN: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 
   // The second child error that turns to a multi-partition error.
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'MULTIPART_DEVICE_UNSUPPORTED: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 
   // The third child error that should be ignored because the error message does
   // not changed.
   chrome.fileBrowserPrivate.onMountCompleted.dispatch({
     status: 'error_internal',
     volumeMetadata: {
       isParentDevice: false,
       deviceType: 'usb',
       devicePath: '/device/path',
       deviceLabel: 'label'
-    }
+    },
+    shouldNotify: true

[mtomasz, 2014/08/26 02:49:43]

nit: Do we have any unit test with shouldNotify = false?

[hirono, 2014/08/26 03:48:26]

Done.

   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals(
       'MULTIPART_DEVICE_UNSUPPORTED: label',
       chrome.notifications.items['deviceFail:/device/path'].message);
 }
 
 function testScanCanceled() {
   registerTypicalDevice();
 
   chrome.fileBrowserPrivate.onDeviceChanged.dispatch({
-    type: 'scan_canceled',
+    type: 'scan_cancelled',
     devicePath: '/device/path'
   });
   assertEquals(0, Object.keys(chrome.notifications.items).length);
 
   // Nothing happened.
   chrome.fileBrowserPrivate.onDeviceChanged.dispatch({
     type: 'removed',
     devicePath: '/device/path'
   });
   assertEquals(0, Object.keys(chrome.notifications.items).length);
@@ skipping 55 matching lines @@
 function testDeviceHardUnplugged() {
   chrome.fileBrowserPrivate.onDeviceChanged.dispatch({
     type: 'hard_unplugged',
     devicePath: '/device/path'
   });
   assertEquals(1, Object.keys(chrome.notifications.items).length);
   assertEquals('DEVICE_HARD_UNPLUGGED_MESSAGE',
                chrome.notifications.items[
                    'hardUnplugged:/device/path'].message);
 }