src/chrome/renderer/resources/extensions/file_system_provider_custom_bindings.js

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Custom binding for the fileSystemProvider API.
   6
   7 var binding = require('binding').Binding.create('fileSystemProvider');
   8 var fileSystemProviderInternal =
   9     require('binding').Binding.create('fileSystemProviderInternal').generate();
  10 var eventBindings = require('event_bindings');
  11 var fileSystemNatives = requireNative('file_system_natives');
  12 var GetDOMError = fileSystemNatives.GetDOMError;
  13
  14 /**
  15  * Annotates a date with its serialized value.
  16  * @param {Date} date Input date.
  17  * @return {Date} Date with an extra <code>value</code> attribute.
  18  */
  19 function annotateDate(date) {
  20   // Copy in case the input date is frozen.
  21   var result = new Date(date.getTime());
  22   result.value = result.toString();
  23   return result;
  24 }
  25
  26 /**
  27  * Annotates an entry metadata by serializing its modifiedTime value.
  28  * @param {EntryMetadata} metadata Input metadata.
  29  * @return {EntryMetadata} metadata Annotated metadata, which can be passed
  30  *     back to the C++ layer.
  31  */
  32 function annotateMetadata(metadata) {
  33   var result = {
  34     isDirectory: metadata.isDirectory,
  35     name: metadata.name,
  36     size: metadata.size,
  37     modificationTime: annotateDate(metadata.modificationTime)
  38   };
  39   return result;
  40 }
  41
  42 binding.registerCustomHook(function(bindingsAPI) {
  43   var apiFunctions = bindingsAPI.apiFunctions;
  44
  45   apiFunctions.setUpdateArgumentsPostValidate(
  46     'mount',
  47     function(displayName, successCallback, errorCallback) {
  48       // Piggyback the error callback onto the success callback,
  49       // so we can use the error callback later.
  50       successCallback.errorCallback_ = errorCallback;
  51       return [displayName, successCallback];
  52     });
  53
  54   apiFunctions.setCustomCallback(
  55     'mount',
  56     function(name, request, response) {
  57       var fileSystemId = null;
  58       var domError = null;
  59       if (request.callback && response) {
  60         fileSystemId = response[0];
  61         // DOMError is present only if mount() failed.
  62         if (response[1]) {
  63           // Convert a Dictionary to a DOMError.
  64           domError = GetDOMError(response[1].name, response[1].message);
  65           response.length = 1;
  66         }
  67
  68         var successCallback = request.callback;
  69         var errorCallback = request.callback.errorCallback_;
  70         delete request.callback;
  71
  72         if (domError)
  73           errorCallback(domError);
  74         else
  75           successCallback(fileSystemId);
  76       }
  77     });
  78
  79   apiFunctions.setUpdateArgumentsPostValidate(
  80     'unmount',
  81     function(fileSystemId, successCallback, errorCallback) {
  82       // Piggyback the error callback onto the success callback,
  83       // so we can use the error callback later.
  84       successCallback.errorCallback_ = errorCallback;
  85       return [fileSystemId, successCallback];
  86     });
  87
  88   apiFunctions.setCustomCallback(
  89     'unmount',
  90     function(name, request, response) {
  91       var domError = null;
  92       if (request.callback) {
  93         // DOMError is present only if mount() failed.
  94         if (response && response[0]) {
  95           // Convert a Dictionary to a DOMError.
  96           domError = GetDOMError(response[0].name, response[0].message);
  97           response.length = 1;
  98         }
  99
 100         var successCallback = request.callback;
 101         var errorCallback = request.callback.errorCallback_;
 102         delete request.callback;
 103
 104         if (domError)
 105           errorCallback(domError);
 106         else
 107           successCallback();
 108       }
 109     });
 110 });
 111
 112 eventBindings.registerArgumentMassager(
 113     'fileSystemProvider.onUnmountRequested',
 114     function(args, dispatch) {
 115       var fileSystemId = args[0];
 116       var requestId = args[1];
 117       var onSuccessCallback = function() {
 118         fileSystemProviderInternal.unmountRequestedSuccess(
 119             fileSystemId, requestId);
 120       };
 121       var onErrorCallback = function(error) {
 122         fileSystemProviderInternal.unmountRequestedError(
 123           fileSystemId, requestId, error);
 124       }
 125       dispatch([fileSystemId, onSuccessCallback, onErrorCallback]);
 126     });
 127
 128 eventBindings.registerArgumentMassager(
 129     'fileSystemProvider.onGetMetadataRequested',
 130     function(args, dispatch) {
 131       var fileSystemId = args[0];
 132       var requestId = args[1];
 133       var entryPath = args[2];
 134       var onSuccessCallback = function(metadata) {
 135         fileSystemProviderInternal.getMetadataRequestedSuccess(
 136             fileSystemId, requestId, annotateMetadata(metadata));
 137       };
 138       var onErrorCallback = function(error) {
 139         fileSystemProviderInternal.getMetadataRequestedError(
 140           fileSystemId, requestId, error);
 141       }
 142       dispatch([fileSystemId, entryPath, onSuccessCallback, onErrorCallback]);
 143     });
 144
 145 eventBindings.registerArgumentMassager(
 146     'fileSystemProvider.onReadDirectoryRequested',
 147     function(args, dispatch) {
 148       var fileSystemId = args[0];
 149       var requestId = args[1];
 150       var directoryPath = args[2];
 151       var onSuccessCallback = function(entries, hasNext) {
 152         var annotatedEntries = entries.map(annotateMetadata);
 153         fileSystemProviderInternal.readDirectoryRequestedSuccess(
 154             fileSystemId, requestId, annotatedEntries, hasNext);
 155       };
 156       var onErrorCallback = function(error) {
 157         fileSystemProviderInternal.readDirectoryRequestedError(
 158             fileSystemId, requestId, error);
 159       }
 160       dispatch([
 161           fileSystemId, directoryPath, onSuccessCallback, onErrorCallback]);
 162     });
 163
 164 exports.binding = binding.generate();