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   if ('mimeType' in metadata)
  40     result.mimeType = metadata.mimeType;
  41   return result;
  42 }
  43
  44 /**
  45  * Massages arguments of an event raised by the File System Provider API.
  46  * @param {Array.<*>} args Input arguments.
  47  * @param {function(Array.<*>)} dispatch Closure to be called with massaged
  48  *     arguments.
  49  */
  50 function massageArgumentsDefault(args, dispatch) {
  51   var executionStart = Date.now();
  52   var options = args[0];
  53   var onSuccessCallback = function(hasNext) {
  54     fileSystemProviderInternal.operationRequestedSuccess(
  55         options.fileSystemId, options.requestId, Date.now() - executionStart);
  56   };
  57   var onErrorCallback = function(error) {
  58     fileSystemProviderInternal.operationRequestedError(
  59         options.fileSystemId, options.requestId, error,
  60         Date.now() - executionStart);
  61   }
  62   dispatch([options, onSuccessCallback, onErrorCallback]);
  63 }
  64
  65
  66 binding.registerCustomHook(function(bindingsAPI) {
  67   var apiFunctions = bindingsAPI.apiFunctions;
  68
  69   apiFunctions.setUpdateArgumentsPostValidate(
  70     'mount',
  71     function(options, successCallback, errorCallback) {
  72       // Piggyback the error callback onto the success callback,
  73       // so we can use the error callback later.
  74       successCallback.errorCallback_ = errorCallback;
  75       return [options, successCallback];
  76     });
  77
  78   apiFunctions.setCustomCallback(
  79     'mount',
  80     function(name, request, response) {
  81       var domError = null;
  82       if (request.callback && response) {
  83         // DOMError is present only if mount() failed.
  84         if (response[0]) {
  85           // Convert a Dictionary to a DOMError.
  86           domError = GetDOMError(response[0].name, response[0].message);
  87           response.length = 1;
  88         }
  89
  90         var successCallback = request.callback;
  91         var errorCallback = request.callback.errorCallback_;
  92         delete request.callback;
  93
  94         if (domError)
  95           errorCallback(domError);
  96         else
  97           successCallback();
  98       }
  99     });
 100
 101   apiFunctions.setUpdateArgumentsPostValidate(
 102     'unmount',
 103     function(options, successCallback, errorCallback) {
 104       // Piggyback the error callback onto the success callback,
 105       // so we can use the error callback later.
 106       successCallback.errorCallback_ = errorCallback;
 107       return [options, successCallback];
 108     });
 109
 110   apiFunctions.setCustomCallback(
 111     'unmount',
 112     function(name, request, response) {
 113       var domError = null;
 114       if (request.callback) {
 115         // DOMError is present only if mount() failed.
 116         if (response && response[0]) {
 117           // Convert a Dictionary to a DOMError.
 118           domError = GetDOMError(response[0].name, response[0].message);
 119           response.length = 1;
 120         }
 121
 122         var successCallback = request.callback;
 123         var errorCallback = request.callback.errorCallback_;
 124         delete request.callback;
 125
 126         if (domError)
 127           errorCallback(domError);
 128         else
 129           successCallback();
 130       }
 131     });
 132 });
 133
 134 eventBindings.registerArgumentMassager(
 135     'fileSystemProvider.onUnmountRequested',
 136     massageArgumentsDefault);
 137
 138 eventBindings.registerArgumentMassager(
 139     'fileSystemProvider.onGetMetadataRequested',
 140     function(args, dispatch) {
 141       var executionStart = Date.now();
 142       var options = args[0];
 143       var onSuccessCallback = function(metadata) {
 144         fileSystemProviderInternal.getMetadataRequestedSuccess(
 145             options.fileSystemId,
 146             options.requestId,
 147             annotateMetadata(metadata),
 148             Date.now() - executionStart);
 149       };
 150       var onErrorCallback = function(error) {
 151         fileSystemProviderInternal.operationRequestedError(
 152             options.fileSystemId, options.requestId, error,
 153             Date.now() - executionStart);
 154       }
 155       dispatch([options, onSuccessCallback, onErrorCallback]);
 156     });
 157
 158 eventBindings.registerArgumentMassager(
 159     'fileSystemProvider.onReadDirectoryRequested',
 160     function(args, dispatch) {
 161       var executionStart = Date.now();
 162       var options = args[0];
 163       var onSuccessCallback = function(entries, hasNext) {
 164         var annotatedEntries = entries.map(annotateMetadata);
 165         fileSystemProviderInternal.readDirectoryRequestedSuccess(
 166             options.fileSystemId, options.requestId, annotatedEntries, hasNext,
 167             Date.now() - executionStart);
 168       };
 169       var onErrorCallback = function(error) {
 170         fileSystemProviderInternal.operationRequestedError(
 171             options.fileSystemId, options.requestId, error,
 172             Date.now() - executionStart);
 173       }
 174       dispatch([options, onSuccessCallback, onErrorCallback]);
 175     });
 176
 177 eventBindings.registerArgumentMassager(
 178     'fileSystemProvider.onOpenFileRequested',
 179     massageArgumentsDefault);
 180
 181 eventBindings.registerArgumentMassager(
 182     'fileSystemProvider.onCloseFileRequested',
 183     massageArgumentsDefault);
 184
 185 eventBindings.registerArgumentMassager(
 186     'fileSystemProvider.onReadFileRequested',
 187     function(args, dispatch) {
 188       var executionStart = Date.now();
 189       var options = args[0];
 190       var onSuccessCallback = function(data, hasNext) {
 191         fileSystemProviderInternal.readFileRequestedSuccess(
 192             options.fileSystemId, options.requestId, data, hasNext,
 193             Date.now() - executionStart);
 194       };
 195       var onErrorCallback = function(error) {
 196         fileSystemProviderInternal.operationRequestedError(
 197             options.fileSystemId, options.requestId, error,
 198             Date.now() - executionStart);
 199       }
 200       dispatch([options, onSuccessCallback, onErrorCallback]);
 201     });
 202
 203 eventBindings.registerArgumentMassager(
 204     'fileSystemProvider.onCreateDirectoryRequested',
 205     massageArgumentsDefault);
 206
 207 eventBindings.registerArgumentMassager(
 208     'fileSystemProvider.onDeleteEntryRequested',
 209     massageArgumentsDefault);
 210
 211 eventBindings.registerArgumentMassager(
 212     'fileSystemProvider.onCreateFileRequested',
 213     massageArgumentsDefault);
 214
 215 eventBindings.registerArgumentMassager(
 216     'fileSystemProvider.onCopyEntryRequested',
 217     massageArgumentsDefault);
 218
 219 eventBindings.registerArgumentMassager(
 220     'fileSystemProvider.onMoveEntryRequested',
 221     massageArgumentsDefault);
 222
 223 eventBindings.registerArgumentMassager(
 224     'fileSystemProvider.onTruncateRequested',
 225     massageArgumentsDefault);
 226
 227 eventBindings.registerArgumentMassager(
 228     'fileSystemProvider.onWriteFileRequested',
 229     massageArgumentsDefault);
 230
 231 exports.binding = binding.generate();