Media Galleries API Picasa: Make PicasaFileUtil support album contents.

chrome/browser/media_galleries/fileapi/picasa/picasa_file_util_unittest.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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/platform_file.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_file_util.h"
 #include "chrome/common/media_galleries/picasa_types.h"
 #include "chrome/common/media_galleries/pmp_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/mock_file_system_options.h"
 #include "webkit/browser/quota/mock_special_storage_policy.h"
+#include "webkit/common/blob/shareable_file_reference.h"
 
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemOperation;
 using fileapi::FileSystemURL;
 
 namespace picasa {
 
 namespace {
 
 base::Time::Exploded test_date_exploded = { 2013, 4, 0, 16, 0, 0, 0, 0 };
 
+bool WriteJPEGHeader(const base::FilePath& path) {
+  const char kJpegHeader[] = "\xFF\xD8\xFF";  // Per HTML5 specification.
+  return file_util::WriteFile(path, kJpegHeader, arraysize(kJpegHeader)) != -1;
+}
+
 class TestFolder {
  public:
   TestFolder(const std::string& name, const base::Time& timestamp,
              const std::string& uid, unsigned int image_files,
              unsigned int non_image_files)
       : name_(name),
         timestamp_(timestamp),
         uid_(uid),
         image_files_(image_files),
         non_image_files_(non_image_files),
         folder_info_("", base::Time(), "", base::FilePath()) {
   }
 
   bool Init() {
     if (!folder_dir_.CreateUniqueTempDir())
       return false;
 
     folder_info_ = AlbumInfo(name_, timestamp_, uid_, folder_dir_.path());
 
-    const char kJpegHeader[] = "\xFF\xD8\xFF";  // Per HTML5 specification.
     for (unsigned int i = 0; i < image_files_; ++i) {
       std::string image_filename = base::StringPrintf("img%05d.jpg", i);
       image_filenames_.insert(image_filename);
 
       base::FilePath path = folder_dir_.path().AppendASCII(image_filename);
 
-      if (file_util::WriteFile(path, kJpegHeader, arraysize(kJpegHeader)) == -1)
+      if (!WriteJPEGHeader(path))
         return false;
     }
 
     for (unsigned int i = 0; i < non_image_files_; ++i) {
       base::FilePath path = folder_dir_.path().AppendASCII(
           base::StringPrintf("hello%05d.txt", i));
       if (file_util::WriteFile(path, NULL, 0) == -1)
         return false;
     }
 
@@ skipping 57 matching lines @@
                              bool* completed) {
   DCHECK(contents);
   DCHECK(completed);
   base::RunLoop run_loop;
   runner->ReadDirectory(
       url, base::Bind(&ReadDirectoryTestHelperCallback, &run_loop, contents,
                       completed));
   run_loop.Run();
 }
 
+void CreateSnapshotFileTestHelperCallback(
+    base::RunLoop* run_loop,
+    base::PlatformFileError* error,
+    base::FilePath* platform_path_result,
+    base::PlatformFileError result,
+    const base::PlatformFileInfo& file_info,
+    const base::FilePath& platform_path,
+    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+  DCHECK(run_loop);
+  DCHECK(error);
+  DCHECK(platform_path_result);
+
+  *error = result;
+  *platform_path_result = platform_path;
+  run_loop->Quit();
+}
+
 }  // namespace
 
 class TestPicasaFileUtil : public PicasaFileUtil {
  public:
   TestPicasaFileUtil(chrome::MediaPathFilter* media_path_filter,
                      PicasaDataProvider* data_provider)
       : PicasaFileUtil(media_path_filter),
         data_provider_(data_provider) {
   }
   virtual ~TestPicasaFileUtil() {}
@@ skipping 81 matching lines @@
   void SetUpOnMediaTaskRunner(base::WaitableEvent* event) {
     picasa_data_provider_.reset(new PicasaDataProvider(base::FilePath()));
     event->Signal();
   }
 
   void TearDownOnMediaTaskRunner(base::WaitableEvent* event) {
     picasa_data_provider_.reset();
     event->Signal();
   }
 
-  void SetupDataProvider(PicasaDataProvider* picasa_data_provider,
-                         const std::vector<AlbumInfo>& albums,
-                         const std::vector<AlbumInfo>& folders) {
-    PicasaDataProvider::UniquifyNames(albums,
-                                      &picasa_data_provider->album_map_);
-    PicasaDataProvider::UniquifyNames(folders,
-                                      &picasa_data_provider->folder_map_);
-    picasa_data_provider->state_ =
-        PicasaDataProvider::ALBUMS_IMAGES_FRESH_STATE;
-  }
-
   // |test_folders| must be in alphabetical order for easy verification
-  void SetupFolders(ScopedVector<TestFolder>* test_folders) {
+  void SetupFolders(ScopedVector<TestFolder>* test_folders,
+                    const std::vector<AlbumInfo>& albums,
+                    const AlbumImagesMap& albums_images) {
     std::vector<AlbumInfo> folders;
     for (ScopedVector<TestFolder>::iterator it = test_folders->begin();
         it != test_folders->end(); ++it) {
       TestFolder* test_folder = *it;
       ASSERT_TRUE(test_folder->Init());
       folders.push_back(test_folder->folder_info());
     }
 
-    SetupDataProvider(
-        picasa_data_provider_.get(), std::vector<AlbumInfo>(), folders);
+    PicasaDataProvider::UniquifyNames(albums,
+                                      &picasa_data_provider_->album_map_);
+    PicasaDataProvider::UniquifyNames(folders,
+                                      &picasa_data_provider_->folder_map_);
+    picasa_data_provider_->albums_images_ = albums_images;
+    picasa_data_provider_->state_ =
+        PicasaDataProvider::ALBUMS_IMAGES_FRESH_STATE;
   }
 
   void VerifyFolderDirectoryList(const ScopedVector<TestFolder>& test_folders) {
     FileSystemOperation::FileEntryList contents;
     FileSystemURL url = CreateURL(kPicasaDirFolders);
     bool completed = false;
     ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
     ASSERT_TRUE(completed);
     ASSERT_EQ(test_folders.size(), contents.size());
@@ skipping 28 matching lines @@
         EXPECT_EQ(1u, image_filenames.count(
             base::FilePath(file_it->name).AsUTF8Unsafe()));
       }
     }
   }
 
   std::string DateToPathString(const base::Time& time) {
     return PicasaDataProvider::DateToPathString(time);
   }
 
-  void TestNonexistentFolder(const std::string& path_append) {
+  void TestNonexistentDirectory(const std::string& path) {
     FileSystemOperation::FileEntryList contents;
-    FileSystemURL url = CreateURL(
-        std::string(kPicasaDirFolders) + path_append);
+    FileSystemURL url = CreateURL(path);
     bool completed = false;
     ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
     ASSERT_FALSE(completed);
   }
 
+  void TestEmptyDirectory(const std::string& path) {
+    FileSystemOperation::FileEntryList contents;
+    FileSystemURL url = CreateURL(path);
+    bool completed = false;
+    ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
+
+    ASSERT_TRUE(completed);
+    EXPECT_EQ(0u, contents.size());
+  }
+
   FileSystemURL CreateURL(const std::string& virtual_path) const {
     return file_system_context_->CreateCrackedFileSystemURL(
         GURL("http://www.example.com"), fileapi::kFileSystemTypePicasa,
         base::FilePath::FromUTF8Unsafe(virtual_path));
   }
 
   fileapi::FileSystemOperationRunner* operation_runner() const {
     return file_system_context_->operation_runner();
   }
 
@@ skipping 48 matching lines @@
   expected_names.push_back("duplicate " + test_date_string + " (1)");
 
   test_folders.push_back(
       new TestFolder("duplicate", test_date, "uuid5", 0, 0));
   expected_names.push_back("duplicate " + test_date_string + " (2)");
 
   test_folders.push_back(
       new TestFolder("unique_name", test_date, "uuid1", 0, 0));
   expected_names.push_back("unique_name " + test_date_string);
 
-  SetupFolders(&test_folders);
+  SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
 
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url = CreateURL(kPicasaDirFolders);
   bool completed = false;
   ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
   ASSERT_TRUE(completed);
   ASSERT_EQ(expected_names.size(), contents.size());
   for (size_t i = 0; i < contents.size(); ++i) {
     EXPECT_EQ(expected_names[i],
               base::FilePath(contents[i].name).AsUTF8Unsafe());
     EXPECT_EQ(test_folders[i]->timestamp(), contents[i].last_modified_time);
     EXPECT_TRUE(contents[i].is_directory);
   }
 }
 
 TEST_F(PicasaFileUtilTest, RootFolders) {
   ScopedVector<TestFolder> empty_folders_list;
-  SetupFolders(&empty_folders_list);
+  SetupFolders(&empty_folders_list, std::vector<AlbumInfo>(), AlbumImagesMap());
 
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url = CreateURL("");
   bool completed = false;
   ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
   ASSERT_TRUE(completed);
   ASSERT_EQ(2u, contents.size());
 
   EXPECT_TRUE(contents.front().is_directory);
   EXPECT_TRUE(contents.back().is_directory);
 
   EXPECT_EQ(0, contents.front().size);
   EXPECT_EQ(0, contents.back().size);
 
   EXPECT_EQ(FILE_PATH_LITERAL("albums"), contents.front().name);
   EXPECT_EQ(FILE_PATH_LITERAL("folders"), contents.back().name);
 }
 
 TEST_F(PicasaFileUtilTest, NonexistentFolder) {
   ScopedVector<TestFolder> empty_folders_list;
-  SetupFolders(&empty_folders_list);
+  SetupFolders(&empty_folders_list, std::vector<AlbumInfo>(), AlbumImagesMap());
 
-  TestNonexistentFolder("/foo");
-  TestNonexistentFolder("/foo/bar");
-  TestNonexistentFolder("/foo/bar/baz");
+  TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo");
+  TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo/bar");
+  TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo/bar/baz");
 }
 
 TEST_F(PicasaFileUtilTest, FolderContentsTrivial) {
   ScopedVector<TestFolder> test_folders;
   base::Time test_date = base::Time::FromLocalExploded(test_date_exploded);
 
   test_folders.push_back(
       new TestFolder("folder-1-empty", test_date, "uid-empty", 0, 0));
   test_folders.push_back(
       new TestFolder("folder-2-images", test_date, "uid-images", 5, 0));
   test_folders.push_back(
       new TestFolder("folder-3-nonimages", test_date, "uid-nonimages", 0, 5));
   test_folders.push_back(
       new TestFolder("folder-4-both", test_date, "uid-both", 5, 5));
 
-  SetupFolders(&test_folders);
+  SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
 TEST_F(PicasaFileUtilTest, FolderWithManyFiles) {
   ScopedVector<TestFolder> test_folders;
   base::Time test_date = base::Time::FromLocalExploded(test_date_exploded);
 
   test_folders.push_back(
       new TestFolder("folder-many-files", test_date, "uid-both", 500, 500));
 
-  SetupFolders(&test_folders);
+  SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
 TEST_F(PicasaFileUtilTest, ManyFolders) {
   ScopedVector<TestFolder> test_folders;
   base::Time test_date = base::Time::FromLocalExploded(test_date_exploded);
 
   // TODO(tommycli): Turn number of test folders back up to 50 (or more) once
   // https://codereview.chromium.org/15479003/ lands.
   for (unsigned int i = 0; i < 25; ++i) {
     base::Time date = test_date - base::TimeDelta::FromDays(i);
 
     test_folders.push_back(
         new TestFolder(base::StringPrintf("folder-%05d", i),
                        date,
                        base::StringPrintf("uid%05d", i), i % 5, i % 3));
   }
 
-  SetupFolders(&test_folders);
+  SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
+TEST_F(PicasaFileUtilTest, AlbumExistence) {
+  ScopedVector<TestFolder> test_folders;
+  base::Time test_date = base::Time::FromLocalExploded(test_date_exploded);
+
+  std::vector<AlbumInfo> albums;
+  AlbumInfo info;
+  info.name = "albumname";
+  info.uid = "albumuid";
+  info.timestamp = test_date;
+  albums.push_back(info);
+
+  AlbumImagesMap albums_images;
+  albums_images[info.uid] = AlbumImages();
+
+  SetupFolders(&test_folders, albums, albums_images);
+
+  TestEmptyDirectory(std::string(kPicasaDirAlbums) + "/albumname 2013-04-16");
+  TestNonexistentDirectory(std::string(kPicasaDirAlbums) +
+                           "/albumname 2013-04-16/toodeep");
+  TestNonexistentDirectory(std::string(kPicasaDirAlbums) + "/wrongname");
+}
+
+TEST_F(PicasaFileUtilTest, AlbumContents) {
+  ScopedVector<TestFolder> test_folders;
+  base::Time test_date = base::Time::FromLocalExploded(test_date_exploded);
+
+  std::vector<AlbumInfo> albums;
+  AlbumInfo info;
+  info.name = "albumname";
+  info.uid = "albumuid";
+  info.timestamp = test_date;
+  albums.push_back(info);
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  base::FilePath image_path = temp_dir.path().AppendASCII("img.jpg");
+  ASSERT_TRUE(WriteJPEGHeader(image_path));
+
+  AlbumImagesMap albums_images;
+  albums_images[info.uid] = AlbumImages();
+  albums_images[info.uid]["mapped_name.jpg"] = image_path;
+
+  SetupFolders(&test_folders, albums, albums_images);
+
+  FileSystemOperation::FileEntryList contents;
+  FileSystemURL url =
+      CreateURL(std::string(kPicasaDirAlbums) + "/albumname 2013-04-16");
+  bool completed = false;
+  ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
+
+  ASSERT_TRUE(completed);
+  EXPECT_EQ(1u, contents.size());
+  EXPECT_EQ("mapped_name.jpg",
+            base::FilePath(contents.begin()->name).AsUTF8Unsafe());
+  EXPECT_FALSE(contents.begin()->is_directory);
+
+  // Create a snapshot file to verify the file path.
+  base::RunLoop loop;
+  base::PlatformFileError error;
+  base::FilePath platform_path_result;
+  fileapi::FileSystemOperationRunner::SnapshotFileCallback snapshot_callback =
+      base::Bind(&CreateSnapshotFileTestHelperCallback,
+                 &loop,
+                 &error,
+                 &platform_path_result);
+  operation_runner()->CreateSnapshotFile(
+      CreateURL(std::string(kPicasaDirAlbums) +
+                "/albumname 2013-04-16/mapped_name.jpg"),
+      snapshot_callback);
+  loop.Run();
+  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(image_path, platform_path_result);
+}
+
 }  // namespace picasa