[filebrowser] More reliable file saving in Photo Editor

chrome/browser/resources/file_manager/js/metadata_dispatcher.js

 // Copyright (c) 2011 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.
 
 // Webworker spec says that the worker global object is called self.  That's
 // a terrible name since we use it all over the chrome codebase to capture
 // the 'this' keyword in lambdas.
 var global = self;
 
 // All of these scripts could be imported with a single call to importScripts,
 // but then load and compile time errors would all be reported from the same
 // line.
 importScripts('metadata_parser.js');
 importScripts('byte_reader.js');
 
 /**
  * Dispatches metadata requests to the correct parser.
  */
 function MetadataDispatcher() {
   importScripts('exif_parser.js');
+  importScripts('image_parsers.js');
   importScripts('mpeg_parser.js');
   importScripts('id3_parser.js');
 
   var patterns = ['blob:'];  // We use blob urls in gallery_demo.js
 
   for (var i = 0; i < MetadataDispatcher.parserClasses_.length; i++) {
     var parserClass = MetadataDispatcher.parserClasses_[i];
-    this.log('new parser: ' + parserClass.parserType);
     var parser = new parserClass(this);
+    this.log('new parser: ' + parser.type);
     this.parserInstances_.push(parser);
     patterns.push(parser.urlFilter.source);
   }
 
   this.parserRegexp_ = new RegExp('(' + patterns.join('|') + ')', 'i');
 }
 
 MetadataDispatcher.parserClasses_ = [];
 
 MetadataDispatcher.registerParserClass = function(parserClass) {
@@ skipping 77 matching lines @@
 
 MetadataDispatcher.prototype.processOneFile = function(fileURL, callback) {
   var self = this;
   var currentStep = -1;
 
   function nextStep(var_args) {
     self.vlog('nextStep: ' + steps[currentStep + 1].name);
     steps[++currentStep].apply(self, arguments);
   }
 
-  // Even if the error occurs we still need to pass mimeType.
-  var metadata = {};
+  var defaultMetadata;  // To pass along with error.
 
   function onError(err, stepName) {
-    self.error(fileURL, stepName || steps[currentStep].name, err, metadata);
+    self.error(fileURL, stepName || steps[currentStep].name, err.toString(),
+        defaultMetadata);
   }
 
   var steps =
   [ // Step one, find the parser matching the url.
     function detectFormat() {
       for (var i = 0; i != self.parserInstances_.length; i++) {
         var parser = self.parserInstances_[i];
         if (fileURL.match(parser.urlFilter)) {
+          defaultMetadata = parser.createDefaultMetadata();
           nextStep(parser);
           return;
         }
       }
       onError('unsupported format');
     },
 
     // Step two, turn the url into an entry.
     function getEntry(parser) {
       webkitResolveLocalFileSystemURL(
           fileURL,
           function(entry) { nextStep(entry, parser) },
           onError);
     },
 
     // Step three, turn the entry into a file.
     function getFile(entry, parser) {
       entry.file(function(file) { nextStep(file, parser) }, onError);
     },
 
     // Step four, parse the file content.
     function parseContent(file, parser) {
-      metadata.mimeType = parser.mimeType;
       parser.parse(file, callback, onError);
     }
   ];
 
   if (fileURL.indexOf('blob:') == 0) {
     // Blob urls require different steps:
     steps =
     [ // Read the blob into an array buffer and get the content type
       function readBlob() {
         var xhr = new XMLHttpRequest();
         xhr.open('GET', fileURL, true);
         xhr.responseType = 'arraybuffer';
         xhr.onload = function(e) {
           if (xhr.status == 200) {
             nextStep(xhr.getResponseHeader('Content-Type'), xhr.response);
           } else {
             onError('HTTP ' + xhr.status);
           }
         };
         xhr.send();
       },
 
       // Step two, find the parser matching the content type.
       function detectFormat(mimeType, arrayBuffer) {
         for (var i = 0; i != self.parserInstances_.length; i++) {
           var parser = self.parserInstances_[i];
-          if (parser.mimeType && mimeType.match(parser.mimeType)) {
+          if (parser.acceptsMimeType(mimeType)) {
+            defaultMetadata = parser.createDefaultMetadata();
             var blobBuilder = new WebKitBlobBuilder();
             blobBuilder.append(arrayBuffer);
             nextStep(blobBuilder.getBlob(), parser);
             return;
           }
         }
         callback({});  // Unrecognized mime type.
       },
 
       // Reuse the last step from the standard sequence.
       steps[steps.length - 1]
     ];
   }
 
   nextStep();
 };
 
 var dispatcher = new MetadataDispatcher();
 global.onmessage = dispatcher.onMessage.bind(dispatcher);