[fsp] Fix crash because of calling net::GetMimeTypeFromFile on UI thread.

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/file_util.h"
 #include "base/files/file_path.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 23 matching lines @@
   if (bytes_read >= 0) {
     net::SniffMimeType(&content[0],
                        bytes_read,
                        net::FilePathToFileURL(local_path),
                        std::string(),  // type_hint (passes no hint)
                        result);
   }
 }
 
 #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);
+}
+
 // Called when fetching MIME type for a non-native local path is completed.
 // If |success| is false, then tries to guess the MIME type by looking at the
 // file name.
-void OnGetMimeTypeForNonNativeLocalPathCompleted(
+void OnGetMimeTypeFromMetadataForNonNativeLocalPathCompleted(
     const base::FilePath& local_path,
     const base::Callback<void(const std::string&)>& callback,
     bool success,
     const std::string& mime_type) {
   if (success) {
     callback.Run(mime_type);
     return;
   }
 
-  std::string mime_type_from_extension;
-  net::GetMimeTypeFromFile(local_path, &mime_type_from_extension);
-  callback.Run(mime_type_from_extension);
+  // MIME type not available with metadata, hence try to guess is from the

[not at google - send to devlin, 2014/07/08 16:02:28]

s/is/it

[mtomasz, 2014/07/09 02:21:02]

Done.

+  // file's extension.
+  scoped_ptr<std::string> mime_type_from_extension(new std::string);
+  std::string* const mime_type_from_extension_ptr =
+      mime_type_from_extension.get();

[not at google - send to devlin, 2014/07/08 16:02:28]

this pattern is such a pain :( it seems like it's not a great fit for
PostBlockingPoolTaskAndReply. would it be easier to just use
PostBlockingPoolTask and manage the fetch/reply yourself?

i.e. basically a much simple async-ifying of all of this logic?

i.e. make GetMimeTypeForLocalPath post to the blocking pool with a method like
GetMimeTypeForLocalPathOnBlockingPool which is basically
GetMimeTypeForLocalPath?

[mtomasz, 2014/07/09 02:21:02]

I'm not a huge fan of it either, but this pattern is often used for
Post*TaskAndReply() in Chromium code and I've been asked several times by
reviewers to go this way rather than post the answer back manually.

WDYT?

[not at google - send to devlin, 2014/07/09 02:38:20]

alright.

but let it be on the record that I think ^ is a much simpler transformation.

+  BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile),
+                 local_path,
+                 mime_type_from_extension_ptr),
+      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) {
   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);
+  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|.
 void GetMimeTypeForLocalPath(
     Profile* profile,
     const base::FilePath& local_path,
     const base::Callback<void(const std::string&)>& callback) {
 #if defined(OS_CHROMEOS)
   if (file_manager::util::IsUnderNonNativeLocalPath(profile, local_path)) {
     // For non-native files, try to get the MIME type from metadata. If not
     // available, then try to guess from the extension. Never sniff (because
     // it can be very slow).
     file_manager::util::GetNonNativeLocalPathMimeType(
         profile,
         local_path,
-        base::Bind(&OnGetMimeTypeForNonNativeLocalPathCompleted,
+        base::Bind(&OnGetMimeTypeFromMetadataForNonNativeLocalPathCompleted,
                    local_path,
                    callback));
     return;
   }
 #endif
 
   // For native local files, try to guess the mime from the extension. If
-  // not availble, then try to sniff if.
-  std::string mime_type_from_extension;
-  if (net::GetMimeTypeFromFile(local_path, &mime_type_from_extension)) {
-    callback.Run(mime_type_from_extension);
-  } else {
-    scoped_ptr<std::string> sniffed_mime_type(new std::string);
-    std::string* 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));
-  }
+  // not available, then try to sniff if.
+  scoped_ptr<std::string> mime_type_from_extension(new std::string);
+  std::string* const mime_type_from_extension_ptr =
+      mime_type_from_extension.get();
+  BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(base::IgnoreResult(&net::GetMimeTypeFromFile),
+                 local_path,
+                 mime_type_from_extension_ptr),
+      base::Bind(&OnGetMimeTypeFromFileForNativeLocalPathCompleted,
+                 local_path,
+                 base::Passed(&mime_type_from_extension),
+                 callback));
 }
 
 MimeTypeCollector::MimeTypeCollector(Profile* profile)
     : profile_(profile), left_(0), weak_ptr_factory_(this) {
 }
 
 MimeTypeCollector::~MimeTypeCollector() {
 }
 
 void MimeTypeCollector::CollectForURLs(
@@ skipping 42 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