Sniff MIME type for files which have unknown extensions.

chrome/browser/chromeos/extensions/file_manager/private_api_tasks.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/chromeos/extensions/file_manager/private_api_tasks.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/file_manager/file_tasks.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/mime_util.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.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 "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
+using content::BrowserThread;
+using extensions::app_file_handler_util::PathAndMimeTypeSet;
 using fileapi::FileSystemURL;
 
 namespace extensions {
 namespace {
 
 // Error messages.
 const char kInvalidFileUrl[] = "Invalid file URL";
 
 // Make a set of unique filename suffixes out of the list of file URLs.
 std::set<std::string> GetUniqueSuffixes(
@@ skipping 97 matching lines @@
   if (params->mime_types.size() != params->file_urls.size() &&
       params->mime_types.size() != 0)
     return false;
 
   const scoped_refptr<fileapi::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // Collect all the URLs, convert them to GURLs, and crack all the urls into
   // file paths.
-  extensions::app_file_handler_util::PathAndMimeTypeSet path_mime_set;
-  std::vector<GURL> file_urls;
+  scoped_ptr<PathAndMimeTypeSet> path_mime_set(new PathAndMimeTypeSet);
+  scoped_ptr<std::vector<GURL> > file_urls(new std::vector<GURL>);
   for (size_t i = 0; i < params->file_urls.size(); ++i) {
     std::string mime_type;
     if (params->mime_types.size() != 0)
       mime_type = params->mime_types[i];
 
     const GURL file_url(params->file_urls[i]);
     fileapi::FileSystemURL file_system_url(
         file_system_context->CrackURL(file_url));
     if (!chromeos::FileSystemBackend::CanHandleURL(file_system_url))
       continue;
     const base::FilePath file_path = file_system_url.path();
 
-    file_urls.push_back(file_url);
+    file_urls->push_back(file_url);
 
     // If MIME type is not provided, guess it from the file path.
     if (mime_type.empty())
       mime_type = file_manager::util::GetMimeTypeForPath(file_path);
 
-    path_mime_set.insert(std::make_pair(file_path, mime_type));
+    path_mime_set->insert(std::make_pair(file_path, mime_type));
   }
 
+  // In case the MIME type of some files are empty,
+  // try to sniff their MIME type by their content.
+  BrowserThread::PostBlockingPoolTask(

[hashimoto, 2014/04/10 09:29:12]

You can use PostBlockingPoolTaskAndReply instead of manually posting the reply.

The code should look like:

PathAndMimeTypeSet* path_mime_set_ptr = path_mime_set.get();
std::vector<GURL>* file_urls_ptr = file_urls.get();

BrowserThread::PostBlockingPoolTask(
  FROM_HERE,
  base::Bind(&StartSniffingMimeType, path_mime_set_ptr, file_urls_ptr),
  base::Bind(&OnSniffingMimeTypeCompleted, base::Passed(&path_mime_set),
base::Passed(&file_urls));

Note: path_mime_set_ptr and file_urls_ptr are necessary because base::Passed may
set NULL to path_mime_set and file_urls.
C++ spec does not define the order of evaluation of function arguments.

[fukino, 2014/04/10 11:12:06]

Thank you for sample code and note!
I would be caught in the trap without your advice.

+      FROM_HERE,
+      base::Bind(&FileBrowserPrivateGetFileTasksFunction::StartSniffingMimeType,
+                 this,
+                 base::Passed(&path_mime_set),
+                 base::Passed(&file_urls)));
+  return true;
+}
+
+void FileBrowserPrivateGetFileTasksFunction::StartSniffingMimeType(

[hashimoto, 2014/04/10 09:29:12]

Since this function is not accessing any member of the class, I think this can
be a free function in the unnamed namespace.

[fukino, 2014/04/10 11:12:06]

Done.

+    scoped_ptr<PathAndMimeTypeSet> path_mime_set,
+    scoped_ptr<std::vector<GURL> > file_urls) {
+  DCHECK(!BrowserThread::CurrentlyOn(content::BrowserThread::UI));

[hashimoto, 2014/04/10 09:29:12]

nit: We usually don't have this kind of DCHECK.
File IO functions like base::ReadFile is already performing
ThreadRestrictions::AssertIOAllowed() in them.

[fukino, 2014/04/10 11:12:06]

Deleted DCHECK.

+
+  scoped_ptr<PathAndMimeTypeSet> sniffed_path_mime_set(new PathAndMimeTypeSet);

[hashimoto, 2014/04/10 09:29:12]

nit: Why don't you modify path_mime_set directly?

[fukino, 2014/04/10 11:12:06]

path_mime_set is std::set, so I avoid modifying keys in the iteration.
(Modifying only mime types won't break the container under condition that the
file paths are unique, though)
(And I don't know why the PathAndMimeSet is set...)

[hashimoto, 2014/04/10 11:54:21]

Ah, that makes sense.
Thank you for clarification.

+  std::vector<char> content(net::kMaxBytesToSniff);
+
+  // For each files, sniff its MIME type if it is empty

[hashimoto, 2014/04/10 09:29:12]

nit: Please add a note about that we sniff local files only.

[fukino, 2014/04/10 11:12:06]

Done.

+  for (PathAndMimeTypeSet::iterator it = path_mime_set->begin();
+       it != path_mime_set->end();
+       ++it) {
+    const base::FilePath& file_path = it->first;
+    std::string mime_type = it->second;
+    if (mime_type.empty() && !drive::util::IsUnderDriveMountPoint(file_path)) {
+      int bytes_read = base::ReadFile(file_path, &content[0], content.size());
+      if (bytes_read >= 0) {
+        net::SniffMimeType(&content[0],
+                           bytes_read,
+                           net::FilePathToFileURL(file_path),
+                           std::string(),
+                           &mime_type);
+      }
+    }
+    sniffed_path_mime_set->insert(std::make_pair(file_path, mime_type));
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &FileBrowserPrivateGetFileTasksFunction::OnSniffingMimeTypeCompleted,
+          this,
+          base::Passed(&sniffed_path_mime_set),
+          base::Passed(&file_urls)));
+}
+
+void FileBrowserPrivateGetFileTasksFunction::OnSniffingMimeTypeCompleted(
+    scoped_ptr<PathAndMimeTypeSet> path_mime_set,
+    scoped_ptr<std::vector<GURL> > file_urls) {
   std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks;
   file_manager::file_tasks::FindAllTypesOfTasks(
       GetProfile(),
       drive::util::GetDriveAppRegistryByProfile(GetProfile()),
-      path_mime_set,
-      file_urls,
+      *path_mime_set,
+      *file_urls,
       &tasks);
 
   // Convert the tasks into JSON compatible objects.
   using api::file_browser_private::FileTask;
   std::vector<linked_ptr<FileTask> > results;
   for (size_t i = 0; i < tasks.size(); ++i) {
     const file_manager::file_tasks::FullTaskDescriptor& task = tasks[i];
     const linked_ptr<FileTask> converted(new FileTask);
     converted->task_id = file_manager::file_tasks::TaskDescriptorToId(
         task.task_descriptor());
     if (!task.icon_url().is_empty())
       converted->icon_url = task.icon_url().spec();
     converted->title = task.task_title();
     converted->is_default = task.is_default();
     results.push_back(converted);
   }
   results_ = extensions::api::file_browser_private::GetFileTasks::Results::
       Create(results);
   SendResponse(true);
-  return true;
 }
 
 bool FileBrowserPrivateSetDefaultTaskFunction::RunImpl() {
   using extensions::api::file_browser_private::SetDefaultTask::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const scoped_refptr<fileapi::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
@@ skipping 19 matching lines @@
     SetResult(new base::FundamentalValue(true));
     return true;
   }
 
   file_manager::file_tasks::UpdateDefaultTask(
       GetProfile()->GetPrefs(), params->task_id, suffixes, mime_types);
   return true;
 }
 
 }  // namespace extensions