Estimate content type from url when it's not available.

ui/file_manager/image_loader/request.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.
 
 /**
  * @typedef {{
  *   cache: (boolean|undefined),
  *   priority: (number|undefined),
  *   taskId: number,
  *   timestamp: (number|undefined),
@@ skipping 210 matching lines @@
   // Download data urls directly since they are not supported by XmlHttpRequest.
   var dataUrlMatches = this.request_.url.match(/^data:([^,;]*)[,;]/);
   if (dataUrlMatches) {
     this.image_.src = this.request_.url;
     this.contentType_ = dataUrlMatches[1];
     return;
   }
 
   // Fetch the image via authorized XHR and parse it.
   var parseImage = function(contentType, blob) {
+    if (contentType)
+      this.contentType_ = contentType;
+
     this.image_.src = URL.createObjectURL(blob);
   }.bind(this);
 
   // Request raw data via XHR.
   this.xhr_.load(this.request_.url, parseImage, onFailure);
 };
 
 /**
  * Creates a XmlHttpRequest wrapper with injected OAuth2 authentication headers.
  * @constructor
  */
 function AuthorizedXHR() {
   this.xhr_ = null;
   this.aborted_ = false;
 }
 
 /**
+ * A map which is used to estimate content type from extension.
+ * @enum {string}
+ */
+AuthorizedXHR.ExtensionContentTypeMap = {
+  gif: 'image/gif',
+  png: 'image/png',
+  svg: 'image/svg',
+  bmp: 'image/bmp',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg'
+};
+
+/**
  * Aborts the current request (if running).
  */
 AuthorizedXHR.prototype.abort = function() {
   this.aborted_ = true;
   if (this.xhr_)
     this.xhr_.abort();
 };
 
 /**
  * Loads an image using a OAuth2 token. If it fails, then tries to retry with
  * a refreshed OAuth2 token.
  *
  * @param {string} url URL to the resource to be fetched.
  * @param {function(string, Blob)} onSuccess Success callback with the content
  *     type and the fetched data.
  * @param {function()} onFailure Failure callback.
  */
 AuthorizedXHR.prototype.load = function(url, onSuccess, onFailure) {
   this.aborted_ = false;
 
   // Do not call any callbacks when aborting.
   var onMaybeSuccess = /** @type {function(string, Blob)} */ (
       function(contentType, response) {
+        // When content type is not available, try to estimate it from url.
+        if (!contentType) {
+          contentType = AuthorizedXHR.ExtensionContentTypeMap[
+              this.extractExtension_(url)];

[fukino, 2015/02/18 10:45:22]

Is reading ExtensionContentTypeMap[null] intended?

[yawano, 2015/02/18 11:32:50]

Yes. Intention is that undefined will be set when content type is not available
for the extension.

+        }
+
         if (!this.aborted_)
           onSuccess(contentType, response);
       }.bind(this));
 
   var onMaybeFailure = /** @type {function(number=)} */ (
       function(opt_code) {
         if (!this.aborted_)
           onFailure();
       }.bind(this));
 
@@ skipping 30 matching lines @@
         onMaybeSuccess,
         onMaybeFailure);
     return;
   }
 
   // Make the request with reusing the current token. If it fails, then retry.
   requestTokenAndCall(false, onMaybeSuccess, maybeRetryCall);
 };
 
 /**
+ * Extracts extension from url.
+ * @param {string} url Url.
+ * @return {?string} Extracted extensiion, e.g. png.
+ */
+AuthorizedXHR.prototype.extractExtension_ = function(url) {
+  var result = (/\.([a-zA-Z]+)$/i).exec(url);
+  return result ? result[1] : null;

[fukino, 2015/02/18 10:45:22]

Returning '' for missing extension looks better for me. (Consistent return type
and consistent with util.splitExtention)

[yawano, 2015/02/18 11:32:50]

Done.

+};
+
+/**
  * Fetches data using authorized XmlHttpRequest with the provided OAuth2 token.
  * If the token is invalid, the request will fail.
  *
  * @param {?string} token OAuth2 token to be injected to the request. Null for
  *     no token.
  * @param {string} url URL to the resource to be fetched.
  * @param {function(string, Blob)} onSuccess Success callback with the content
  *     type and the fetched data.
  * @param {function(number=)} onFailure Failure callback with the error code
  *     if available.
@@ skipping 139 matching lines @@
   this.image_.src = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAA' +
       'ABAAEAAAICTAEAOw==';
 
   this.xhr_.onload = function() {};
   this.xhr_.abort();
 
   // Dispose memory allocated by Canvas.
   this.canvas_.width = 0;
   this.canvas_.height = 0;
 };