Don't crash browser process when OK passed as error code in FSP API.

chrome/renderer/resources/extensions/file_system_provider_custom_bindings.js

 // Copyright 2013 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.
 
 // Custom binding for the fileSystemProvider API.
 
 var binding = require('binding').Binding.create('fileSystemProvider');
 var fileSystemProviderInternal =
     require('binding').Binding.create('fileSystemProviderInternal').generate();
 var eventBindings = require('event_bindings');
@@ skipping 102 matching lines @@
   if (metadata.thumbnail !== undefined &&
       metadata.thumbnail.length > METADATA_THUMBNAIL_SIZE_LIMIT) {
     console.error('Thumbnail data too large.');
     return false;
   }
 
   return true;
 }
 
 /**
+ * Verifies if the passed error code is valid when used to indicate
+ * a failure.
+ * @param {!string} error
+ * @return {boolean} True if valid, false if invalid.
+ */
+function verifyErrorForFailure(error) {
+  if (error === 'OK') {
+    console.error('Error code cannot be OK in case of failures.');
+    return false;
+  }
+  return true;
+}
+
+/**
  * Annotates an entry metadata by serializing its modifiedTime value.
  * @param {EntryMetadata} metadata Input metadata.
  * @return {EntryMetadata} metadata Annotated metadata, which can be passed
  *     back to the C++ layer.
  */
 function annotateMetadata(metadata) {
   var result = {};
   if (metadata.isDirectory !== undefined)
     result.isDirectory = metadata.isDirectory;
   if (metadata.name !== undefined)
@@ skipping 16 matching lines @@
  *     arguments.
  */
 function massageArgumentsDefault(args, dispatch) {
   var executionStart = Date.now();
   var options = args[0];
   var onSuccessCallback = function(hasNext) {
     fileSystemProviderInternal.operationRequestedSuccess(
         options.fileSystemId, options.requestId, Date.now() - executionStart);
   };
   var onErrorCallback = function(error) {
+    if (!verifyErrorForFailure(error))
+      return;
     fileSystemProviderInternal.operationRequestedError(
         options.fileSystemId, options.requestId, error,
         Date.now() - executionStart);
   }
   dispatch([options, onSuccessCallback, onErrorCallback]);
 }
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onUnmountRequested',
     massageArgumentsDefault);
@@ skipping 12 matching lines @@
         }
 
         fileSystemProviderInternal.getMetadataRequestedSuccess(
             options.fileSystemId,
             options.requestId,
             annotateMetadata(metadata),
             Date.now() - executionStart);
       };
 
       var onErrorCallback = function(error) {
+        if (!verifyErrorForFailure(error))
+          return;
         fileSystemProviderInternal.operationRequestedError(
             options.fileSystemId, options.requestId, error,
             Date.now() - executionStart);
       }
 
       dispatch([options, onSuccessCallback, onErrorCallback]);
     });
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onGetActionsRequested',
     function(args, dispatch) {
       var executionStart = Date.now();
       var options = args[0];
       var onSuccessCallback = function(actions) {
         fileSystemProviderInternal.getActionsRequestedSuccess(
             options.fileSystemId,
             options.requestId,
             actions,
             Date.now() - executionStart);
       };
 
       var onErrorCallback = function(error) {
+        if (!verifyErrorForFailure(error))
+          return;
         fileSystemProviderInternal.operationRequestedError(
             options.fileSystemId, options.requestId, error,
             Date.now() - executionStart);
       }
 
       dispatch([options, onSuccessCallback, onErrorCallback]);
     });
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onReadDirectoryRequested',
@@ skipping 16 matching lines @@
           return;
         }
 
         var annotatedEntries = entries.map(annotateMetadata);
         fileSystemProviderInternal.readDirectoryRequestedSuccess(
             options.fileSystemId, options.requestId, annotatedEntries, hasNext,
             Date.now() - executionStart);
       };
 
       var onErrorCallback = function(error) {
+        if (!verifyErrorForFailure(error))
+          return;
         fileSystemProviderInternal.operationRequestedError(
             options.fileSystemId, options.requestId, error,
             Date.now() - executionStart);
       }
       dispatch([options, onSuccessCallback, onErrorCallback]);
     });
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onOpenFileRequested',
     massageArgumentsDefault);
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onCloseFileRequested',
     massageArgumentsDefault);
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onReadFileRequested',
     function(args, dispatch) {
       var executionStart = Date.now();
       var options = args[0];
       var onSuccessCallback = function(data, hasNext) {
         fileSystemProviderInternal.readFileRequestedSuccess(
             options.fileSystemId, options.requestId, data, hasNext,
             Date.now() - executionStart);
       };
       var onErrorCallback = function(error) {
+        if (!verifyErrorForFailure(error))
+          return;
         fileSystemProviderInternal.operationRequestedError(
             options.fileSystemId, options.requestId, error,
             Date.now() - executionStart);
       }
       dispatch([options, onSuccessCallback, onErrorCallback]);
     });
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onCreateDirectoryRequested',
     massageArgumentsDefault);
@@ skipping 50 matching lines @@
     'fileSystemProvider.onExecuteActionRequested',
     massageArgumentsDefault);
 
 eventBindings.registerArgumentMassager(
     'fileSystemProvider.onMountRequested',
     function(args, dispatch) {
       var onSuccessCallback = function() {
         // TODO(mtomasz): To be implemented.
       };
       var onErrorCallback = function(error) {
+        verifyErrorForFailure(error);

[benwells, 2017/01/30 01:50:50]

Nit: should this bail on failure like the other onErrorCallbacks?

[mtomasz, 2017/02/21 05:25:59]

Do you mean return if returned false? It would be a no-op here. If your question
is why we don't call fileSystemProviderInternal.operationRequestError here like
in other onErrorCallbacks, then the answer is I don't remember :(.

It's quite parallel to the issue this CL is addressing, so would you mind if I
look at it separately?

[benwells, 2017/02/21 05:35:11]

That is what I meant. It would be a no-op, but would be clear to whoever has to
come and implement the TODO.

If your question

[mtomasz, 2017/02/21 05:56:43]

I took a look at the original CL adding this TODO, and there is nothing to
implement here until we have more clients dispatching this event. It's unlikely
to happen, so removed the TODO and replaced with a comment.

         // TODO(mtomasz): To be implemented.
       }
       dispatch([onSuccessCallback, onErrorCallback]);
     });
 
 exports.$set('binding', binding.generate());