Have media gallery (through native media file util) use MIME sniffer

webkit/fileapi/media/native_media_file_util.cc

 // Copyright (c) 2012 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 "webkit/fileapi/media/native_media_file_util.h"
 
+#include "base/memory/scoped_generic_obj.h"
+#include "base/string_util.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/mime_sniffer.h"
+#include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
+#include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/media/media_path_filter.h"
 #include "webkit/fileapi/media/filtering_file_enumerator.h"
 #include "webkit/fileapi/native_file_util.h"
 
 using base::PlatformFile;
 using base::PlatformFileError;
 using base::PlatformFileInfo;
 
+namespace {
+
+// Modelled after ScopedFILEClose.
+class ScopedPlatformFileClose {
+ public:
+  void operator()(base::PlatformFile file) const {
+    base::ClosePlatformFile(file);

[vandebo (ex-Chrome), 2013/04/12 20:57:40]

I think you need to check that the file handle is valid before closing it.  For
example, see
https://code.google.com/p/chromium/codesearch/#chromium/src/base/platform_fil...

[Kevin Bailey, 2013/04/12 22:58:35]

I can of course make that tiny change, but realize it won't do anything about
the real danger: Creating a ScopedPlatformFile with an uninitialized handle, or
worse, one that happens to point to a opened file. Functions like
NativeFileUtil::CreateOrOpen() don't set the handle on error, so you really have
to check anyways.

[vandebo (ex-Chrome), 2013/04/15 20:01:47]

It looks like you're current use of it is ok.  The code checks that the there
was no error before assigning to the ScopedPlatformFile 

+  }
+};
+
+typedef ScopedGenericObj<base::PlatformFile,
+                         ScopedPlatformFileClose> ScopedPlatformFile;
+
+// Returns true if the current thread is capable of doing IO.
+bool IsOnTaskRunnerThread(fileapi::FileSystemOperationContext* context) {
+  return context->file_system_context()->task_runners()->
+      media_task_runner()->RunsTasksOnCurrentThread();
+}
+
+}
+
 namespace fileapi {
 
 NativeMediaFileUtil::NativeMediaFileUtil() {
 }
 
 PlatformFileError NativeMediaFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     int file_flags,
     PlatformFile* file_handle,
@@ skipping 180 matching lines @@
 
   if (!file_info.is_directory &&
       !context->media_path_filter()->Match(file_path)) {
     return failure_error;
   }
 
   *local_file_path = file_path;
   return base::PLATFORM_FILE_OK;
 }
 
+base::PlatformFileError NativeMediaFileUtil::CreateSnapshotFile(
+    FileSystemOperationContext* context,
+    const FileSystemURL& url,
+    base::PlatformFileInfo* file_info,
+    base::FilePath* platform_path,
+    SnapshotFilePolicy* policy) {
+  DCHECK(IsOnTaskRunnerThread(context));
+  base::PlatformFileError error = IsolatedFileUtil::CreateSnapshotFile(
+      context, url, file_info, platform_path, policy);
+  if (error != base::PLATFORM_FILE_OK)
+    return error;
+  return IsMediaFile(*platform_path);
+}
+
+base::PlatformFileError NativeMediaFileUtil::IsMediaFile(
+    const base::FilePath& path) {
+  base::PlatformFile file_handle;
+  bool created;
+  base::PlatformFileError error;
+  error = NativeFileUtil::CreateOrOpen(path,
+      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, &file_handle,
+      &created);
+  if (error != base::PLATFORM_FILE_OK)
+    return error;
+  ScopedPlatformFile scoped_platform_file(file_handle);
+  char buffer[net::kMaxBytesToSniff];
+  int64 len;
+  // Read as much as SniffMimeType() will bother looking at.
+  len = base::ReadPlatformFile(file_handle, 0, buffer, net::kMaxBytesToSniff);
+  if (len < 0)
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  if (len == 0)
+    return base::PLATFORM_FILE_ERROR_SECURITY;
+  std::string mime_type;
+  if (!net::SniffMimeType(buffer, len, GURL("file://" + path.value()),
+                          "no/idea", &mime_type)) {
+    return base::PLATFORM_FILE_ERROR_SECURITY;
+  }
+  if (StartsWithASCII(mime_type, "image/", true) ||
+      StartsWithASCII(mime_type, "audio/", true) ||
+      StartsWithASCII(mime_type, "video/", true)) {
+    return base::PLATFORM_FILE_OK;
+  } else {
+    return base::PLATFORM_FILE_ERROR_SECURITY;
+  }
+}
+
 }  // namespace fileapi