Do not handle a file as application/zip when the extension is not .zip.

chrome/browser/extensions/api/file_handlers/mime_util.cc

 // 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.
 
 #include "chrome/browser/extensions/api/file_handlers/mime_util.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 19 matching lines @@
 
   const int bytes_read =
       base::ReadFile(local_path, &content[0], content.size());
 
   if (bytes_read >= 0) {
     net::SniffMimeType(&content[0],
                        bytes_read,
                        net::FilePathToFileURL(local_path),
                        std::string(),  // type_hint (passes no hint)
                        result);
+
+    // If the extension is not .zip, do not handle the file as application/zip
+    // since it might be unknown internally zipped file.
+    if (*result == "application/zip" &&
+        local_path.Extension() != FILE_PATH_LITERAL(".zip"))

[benwells, 2015/04/14 21:57:22]

The logic of this flow is, I think:
- return the mime type from the extension, if it isn't empty, otherwise
- return the sniffed mime type from the contents, except if the extension is not
zip and the mime type is, in which case return the applicaiton/octet-stream

This doesn't seem that clean. In particular:
- if there are other valid application/zip extensions this now feels
inconsistent
- but, there shouldn't be any need to check the extension as .zip files
shouldn't end up being sniffed anyway

Instead of doing this you could add something to the handler of this
(OnSniffMimeTYpeForNativeLocalPathCompleted) which checks the returned
mime_type:
  if (*mime_type == "application/zip") {
    callback.Run("application/octet-stream");
    return;
  }

  callback.Run(*mime_type)

THat way you don't redundantly check the extension again.

But, maybe I'm missing some reason to do it this way...

[yawano, 2015/04/15 03:41:34]

Moving to OnSniffMimeTypeForNativeLocalPathCompleted seems to be better. I moved
it.

+      result->assign("application/octet-stream");

[benwells, 2015/04/14 21:57:22]

Why is the default application/octet-stream? Is that the default we always use?

[yawano, 2015/04/15 03:41:34]

I think there is no default mime type. The default value of mime type is empty
string.

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

The reason that we selected application/octet-stream is that generic mime type
should be less confusing.

   }
 }
 
 #if defined(OS_CHROMEOS)
 // Converts a result passed as a scoped pointer to a dereferenced value passed
 // to |callback|.
 void OnGetMimeTypeFromFileForNonNativeLocalPathCompleted(
     scoped_ptr<std::string> mime_type,
     const base::Callback<void(const std::string&)>& callback) {
   callback.Run(*mime_type);
@@ skipping 148 matching lines @@
         FROM_HERE, base::Bind(callback_, base::Passed(&result_)));
     // Release the callback to avoid a circullar reference in case an instance
     // of this class is a member of a ref counted class, which instance is bound
     // to this callback.
     callback_ = CompletionCallback();
   }
 }
 
 }  // namespace app_file_handler_util
 }  // namespace extensions