Files.app: Start to use DeviceEventRouter.

ui/file_manager/file_manager/background/js/device_handler.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';
 
 /**
  * Handler of device event.
  * @constructor
  * @extends {cr.EventTarget}
@@ skipping 79 matching lines @@
    */
   this.buttonLabel = opt_buttonLabel || null;
 
   /**
    * Queue of API call.
    * @type {AsyncUtil.Queue}
    * @private
    */
   this.queue_ = new AsyncUtil.Queue();
 
-  /**
-   * Timeout ID.
-   * @type {number}
-   * @private
-   */
-  this.pendingShowTimerId_ = 0;
-
   Object.seal(this);
 };
 
 /**
  * @type {DeviceHandler.Notification}
  * @const
  */
 DeviceHandler.Notification.DEVICE = new DeviceHandler.Notification(
     'device',
     'REMOVABLE_DEVICE_DETECTION_TITLE',
@@ skipping 65 matching lines @@
     'FORMATTING_OF_DEVICE_FAILED_TITLE',
     'FORMATTING_FINISHED_FAILURE_MESSAGE');
 
 /**
  * Shows the notification for the device path.
  * @param {string} devicePath Device path.
  * @param {string=} opt_message Message overrides the default message.
  * @return {string} Notification ID.
  */
 DeviceHandler.Notification.prototype.show = function(devicePath, opt_message) {
-  this.clearTimeout_();
   var notificationId = this.makeId_(devicePath);
   this.queue_.run(function(callback) {
     var buttons =
         this.buttonLabel ? [{title: str(this.buttonLabel)}] : undefined;
     chrome.notifications.create(
         notificationId,
         {
           type: 'basic',
           title: str(this.title),
           message: opt_message || str(this.message),
           iconUrl: chrome.runtime.getURL('/common/images/icon96.png'),
           buttons: buttons
         },
         callback);
   }.bind(this));
   return notificationId;
 };
 
 /**
- * Shows the notification after 5 seconds.
- * @param {string} devicePath Device path.
- */
-DeviceHandler.Notification.prototype.showLater = function(devicePath) {
-  this.clearTimeout_();
-  this.pendingShowTimerId_ = setTimeout(this.show.bind(this, devicePath), 5000);
-};
-
-/**
  * Hides the notification for the device path.
  * @param {string} devicePath Device path.
  */
 DeviceHandler.Notification.prototype.hide = function(devicePath) {
-  this.clearTimeout_();
   this.queue_.run(function(callback) {
     chrome.notifications.clear(this.makeId_(devicePath), callback);
   }.bind(this));
 };
 
 /**
  * Makes a notification ID for the device path.
  * @param {string} devicePath Device path.
  * @return {string} Notification ID.
  * @private
  */
 DeviceHandler.Notification.prototype.makeId_ = function(devicePath) {
   return this.prefix + ':' + devicePath;
 };
 
 /**
- * Cancels the timeout request.
- * @private
- */
-DeviceHandler.Notification.prototype.clearTimeout_ = function() {
-  if (this.pendingShowTimerId_) {
-    clearTimeout(this.pendingShowTimerId_);
-    this.pendingShowTimerId_ = 0;
-  }
-};
-
-/**
  * Handles notifications from C++ sides.
  * @param {DeviceEvent} event Device event.
  * @private
  */
 DeviceHandler.prototype.onDeviceChanged_ = function(event) {
   switch (event.type) {
-    case 'added':
-      if (!this.isStartup_)
-        DeviceHandler.Notification.DEVICE.showLater(event.devicePath);
-      this.mountStatus_[event.devicePath] = DeviceHandler.MountStatus.NO_RESULT;
+    case 'scan_started':
+      DeviceHandler.Notification.DEVICE.show(event.devicePath);
+      break;
+    case 'scan_cancelled':
+      DeviceHandler.Notification.DEVICE.hide(event.devicePath);
       break;
     case 'disabled':
       DeviceHandler.Notification.DEVICE_EXTERNAL_STORAGE_DISABLED.show(
           event.devicePath);
       break;
-    case 'scan_canceled':
-      DeviceHandler.Notification.DEVICE.hide(event.devicePath);
-      break;
     case 'removed':
       DeviceHandler.Notification.DEVICE.hide(event.devicePath);
       DeviceHandler.Notification.DEVICE_FAIL.hide(event.devicePath);
       DeviceHandler.Notification.DEVICE_EXTERNAL_STORAGE_DISABLED.hide(
           event.devicePath);
       delete this.mountStatus_[event.devicePath];
       break;
     case 'hard_unplugged':
       if (!this.isStartup_) {
         DeviceHandler.Notification.DEVICE_HARD_UNPLUGGED.show(
             event.devicePath);
       }
       break;
     case 'format_start':
       DeviceHandler.Notification.FORMAT_START.show(event.devicePath);
       break;
     case 'format_success':
       DeviceHandler.Notification.FORMAT_START.hide(event.devicePath);
       DeviceHandler.Notification.FORMAT_SUCCESS.show(event.devicePath);
       break;
     case 'format_fail':
       DeviceHandler.Notification.FORMAT_START.hide(event.devicePath);
       DeviceHandler.Notification.FORMAT_FAIL.show(event.devicePath);
       break;
+    default:
+      console.error('Unknown event tyep: ' + event.type);
+      break;
   }
 };
 
 /**
  * Mount status for the device.
  * Each multi-partition devices can obtain multiple mount completed events.
  * This status shows what results are already obtained for the device.
  * @enum {string}
  * @const
  */
@@ skipping 12 matching lines @@
 
 /**
  * Handles mount completed events to show notifications for removable devices.
  * @param {MountCompletedEvent} event Mount completed event.
  * @private
  */
 DeviceHandler.prototype.onMountCompleted_ = function(event) {
   // If this is remounting, which happens when resuming ChromeOS, the device has
   // already inserted to the computer. So we suppress the notification.
   var volume = event.volumeMetadata;
-  if (!volume.deviceType || event.isRemounting)
+  if (!volume.deviceType || !event.shouldNotify)
     return;
 
   // If the current volume status is succeed and it should be handled in
   // Files.app, show the notification to navigate the volume.
-  if (event.status === 'success' && event.shouldNotify) {
+  if (event.eventType === 'mount' &&
+      event.status === 'success') {
     if (this.navigationVolumes_[event.volumeMetadata.devicePath]) {
       // The notification has already shown for the device. It seems the device
       // has multiple volumes. The order of mount events of volumes are
       // undetermind, so it compares the volume Id and uses the earier order ID
       // to prevent Files.app from navigating to different volumes for each
       // time.
       if (event.volumeMetadata.volumeId <
           this.navigationVolumes_[event.volumeMetadata.devicePath]) {
         this.navigationVolumes_[event.volumeMetadata.devicePath] =
             event.volumeMetadata.volumeId;
@@ skipping 16 matching lines @@
   var getFirstStatus = function(event) {
     if (event.status === 'success')
       return DeviceHandler.MountStatus.SUCCESS;
     else if (event.volumeMetadata.isParentDevice)
       return DeviceHandler.MountStatus.ONLY_PARENT_ERROR;
     else
       return DeviceHandler.MountStatus.CHILD_ERROR;
   };
 
   // Update the current status.
+  if (!this.mountStatus_[volume.devicePath])
+    this.mountStatus_[volume.devicePath] = DeviceHandler.MountStatus.NO_RESULT;
   switch (this.mountStatus_[volume.devicePath]) {
-    // If there is no related device, do nothing.
-    case undefined:
-      return;
     // If the multipart error message has already shown, do nothing because the
     // message does not changed by the following mount results.
     case DeviceHandler.MountStatus.MULTIPART_ERROR:
       return;
     // If this is the first result, hide the scanning notification.
     case DeviceHandler.MountStatus.NO_RESULT:
       DeviceHandler.Notification.DEVICE.hide(volume.devicePath);
       this.mountStatus_[volume.devicePath] = getFirstStatus(event);
       break;
     // If there are only parent errors, and the new result is child's one, hide
@@ skipping 65 matching lines @@
     this.dispatchEvent(event);
   }
 };
 
 DeviceHandler.prototype.onStartup_ = function() {
   this.isStartup_ = true;
   setTimeout(function() {
     this.isStartup_ = false;
   }.bind(this), 5000);
 };