Add a copy or move validator to that can handle support audio and video files.

chrome/browser/media_galleries/fileapi/media_file_validator_browsertest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/path_service.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/mock_file_system_context.h"
 #include "webkit/browser/fileapi/test_file_system_backend.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 namespace {
 
 const char kOrigin[] = "http://foo";
 
 const char kValidImage[] = "RIFF0\0\0\0WEBPVP8 $\0\0\0\xB2\x02\0\x9D\x01\x2A"
                            "\x01\0\x01\0\x2F\x9D\xCE\xE7s\xA8((((\x01\x9CK(\0"
                            "\x05\xCE\xB3l\0\0\xFE\xD8\x80\0\0";
 
-const char kInvalidImage[] = "Not an image";
+const char kInvalidMediaFile[] = "Not a media file";
 
 const int64 kNoFileSize = -1;
 
 void HandleCheckFileResult(int64 expected_size,
                            const base::Callback<void(bool success)>& callback,
                            base::PlatformFileError result,
                            const base::PlatformFileInfo& file_info) {
   if (result == base::PLATFORM_FILE_OK) {
     if (!file_info.is_directory && expected_size != kNoFileSize &&
         file_info.size == expected_size) {
       callback.Run(true);
       return;
     }
   } else {
     if (expected_size == kNoFileSize) {
       callback.Run(true);
       return;
     }
   }
   callback.Run(false);
 }
 
+base::FilePath GetMediaTestDir() {
+  base::FilePath test_file;
+  if (!PathService::Get(base::DIR_SOURCE_ROOT, &test_file))
+    return base::FilePath();
+  return test_file.AppendASCII("media").AppendASCII("test").AppendASCII("data");
+}
+
 }  // namespace
 
 namespace chrome {
 
 class MediaFileValidatorTest : public InProcessBrowserTest {
  public:
   MediaFileValidatorTest() : test_file_size_(0) {}
 
   virtual ~MediaFileValidatorTest() {}
 
   // Write |content| into |filename| in a test file system and try to move
   // it into a media file system.  The result is compared to |expected_result|.
   void MoveTest(const std::string& filename, const std::string& content,
                 bool expected_result) {
     content::BrowserThread::PostTask(
         content::BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&MediaFileValidatorTest::SetupOnFileThread,
                    base::Unretained(this), filename, content, expected_result));
     loop_runner_ = new content::MessageLoopRunner;
     loop_runner_->Run();
   }
 
+  // Write |source| into |filename| in a test file system and try to move it
+  // into a media file system.  The result is compared to |expected_result|.
+  void MoveTestFromFile(const std::string& filename,
+                        const base::FilePath& source, bool expected_result) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&MediaFileValidatorTest::SetupFromFileOnFileThread,
+                   base::Unretained(this), filename, source, expected_result));
+    loop_runner_ = new content::MessageLoopRunner;
+    loop_runner_->Run();
+  }
+
  private:
   // Create the test files, filesystem objects, etc.
   void SetupOnFileThread(const std::string& filename,
                          const std::string& content,
                          bool expected_result) {
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
     base::FilePath base = base_dir_.path();
     base::FilePath src_path = base.AppendASCII("src_fs");
     ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
@@ skipping 31 matching lines @@
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaFileValidatorTest::CheckFiles,
                    base::Unretained(this), true,
                    base::Bind(&MediaFileValidatorTest::OnTestFilesReady,
                               base::Unretained(this), expected_result)));
   }
 
+  void SetupFromFileOnFileThread(const std::string& filename,
+                                 const base::FilePath& source,
+                                 bool expected_result) {
+    std::string content;
+    ASSERT_TRUE(file_util::ReadFileToString(source, &content));
+    SetupOnFileThread(filename, content, expected_result);
+  }
+
   // Check that exactly one of |move_src_| and |move_dest_| exists.
   // |src_expected| indicates which one should exist.  When complete,
   // |callback| is called with success/failure.
   void CheckFiles(bool src_expected,
                   const base::Callback<void(bool success)>& callback) {
     CheckFile(move_src_, src_expected ? test_file_size_ : kNoFileSize,
               base::Bind(&MediaFileValidatorTest::OnCheckFilesFirstResult,
                          base::Unretained(this), !src_expected, callback));
   }
 
@@ skipping 63 matching lines @@
   int test_file_size_;
 
   fileapi::FileSystemURL move_src_;
   fileapi::FileSystemURL move_dest_;
 
   scoped_refptr<content::MessageLoopRunner> loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaFileValidatorTest);
 };
 
+IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, UnsupportedExtension) {
+  MoveTest("a.txt", std::string(kValidImage, arraysize(kValidImage)), false);
+}
+
 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidImage) {
   MoveTest("a.webp", std::string(kValidImage, arraysize(kValidImage)), true);
 }
 
 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidImage) {
-  MoveTest("a.webp", std::string(kInvalidImage, arraysize(kInvalidImage)),
-           false);
+  MoveTest("a.webp", std::string(kInvalidMediaFile,
+           arraysize(kInvalidMediaFile)), false);
 }
 
-IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, UnsupportedExtension) {
-  MoveTest("a.txt", std::string(kValidImage, arraysize(kValidImage)), false);
+IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidAudio) {
+  MoveTest("a.ogg", std::string(kInvalidMediaFile,
+           arraysize(kInvalidMediaFile)), false);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidAudio) {
+  base::FilePath test_file = GetMediaTestDir();
+  ASSERT_FALSE(test_file.empty());
+  test_file = test_file.AppendASCII("sfx.ogg");
+  MoveTestFromFile("sfx.ogg", test_file, true);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidVideo) {
+  base::FilePath test_file = GetMediaTestDir();
+  ASSERT_FALSE(test_file.empty());
+  test_file = test_file.AppendASCII("no_streams.webm");
+  MoveTestFromFile("no_streams.webm", test_file, false);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidVideo) {
+  base::FilePath test_file = GetMediaTestDir();
+  ASSERT_FALSE(test_file.empty());
+  test_file = test_file.AppendASCII("bear-320x240-multitrack.webm");
+  MoveTestFromFile("multitrack.webm", test_file, true);
 }
 
 }  // namespace chrome