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"
 #include "net/base/filename_util.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
 #endif
 
 using content::BrowserThread;
 
+namespace {
+
+const char kMimeTypeApplicationOctetStream[] = "application/octet-stream";
+
+}  // namespace
+
 namespace extensions {
 namespace app_file_handler_util {
 namespace {
 
 // Detects MIME type by reading initial bytes from the file. If found, then
 // writes the MIME type to |result|.
 void SniffMimeType(const base::FilePath& local_path, std::string* result) {
   std::vector<char> content(net::kMaxBytesToSniff);
 
   const int bytes_read =
@@ skipping 43 matching lines @@
       base::Bind(&OnGetMimeTypeFromFileForNonNativeLocalPathCompleted,
                  base::Passed(&mime_type_from_extension),
                  callback));
 }
 #endif
 
 // Called when sniffing for MIME type in the native local file is completed.
 void OnSniffMimeTypeForNativeLocalPathCompleted(
     scoped_ptr<std::string> mime_type,
     const base::Callback<void(const std::string&)>& callback) {
+  // Do not return application/zip as sniffed result. If the file has .zip
+  // extension, it should be already returned as application/zip. If the file
+  // does not have .zip extension and couldn't find mime type from the
+  // extension, it might be unknown internally zipped file.
+  if (*mime_type == "application/zip") {
+    callback.Run(kMimeTypeApplicationOctetStream);
+    return;
+  }
+
   callback.Run(*mime_type);
 }
 
 }  // namespace
 
 // Handles response of net::GetMimeTypeFromFile for native file systems. If
 // MIME type is available, then forwards it to |callback|. Otherwise, fallbacks
 // to sniffing.
 void OnGetMimeTypeFromFileForNativeLocalPathCompleted(
     const base::FilePath& local_path,
     scoped_ptr<std::string> mime_type,
     const base::Callback<void(const std::string&)>& callback) {
   if (!mime_type->empty()) {
     callback.Run(*mime_type);
     return;
   }
 
-  scoped_ptr<std::string> sniffed_mime_type(new std::string);
+  scoped_ptr<std::string> sniffed_mime_type(
+      new std::string(kMimeTypeApplicationOctetStream));
   std::string* const sniffed_mime_type_ptr = sniffed_mime_type.get();
   BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&SniffMimeType, local_path, sniffed_mime_type_ptr),
       base::Bind(&OnSniffMimeTypeForNativeLocalPathCompleted,
                  base::Passed(&sniffed_mime_type),
                  callback));
 }
 
 // Fetches MIME type for a local path and returns it with a |callback|.
@@ skipping 85 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