Media Galleries API Picasa: Add file watch to invalidate database data on disk write.

chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider_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/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider.h"
 #include "chrome/browser/media_galleries/fileapi/safe_picasa_albums_indexer.h"
 #include "chrome/common/media_galleries/picasa_types.h"
 #include "chrome/common/media_galleries/pmp_test_helper.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/test/test_browser_thread.h"
 
 using chrome::MediaFileSystemBackend;
 
 namespace picasa {
 
 namespace {
 
-void WriteTestAlbumTable(PmpTestHelper* test_helper,
-                         base::FilePath test_folder_1_path,
-                         base::FilePath test_folder_2_path) {
+void WriteTestAlbumTable(const PmpTestHelper* test_helper,
+                         const base::FilePath& test_folder_1_path,
+                         const base::FilePath& test_folder_2_path) {
   std::vector<uint32> category_vector;
   category_vector.push_back(kAlbumCategoryFolder);
   category_vector.push_back(kAlbumCategoryInvalid);
   category_vector.push_back(kAlbumCategoryAlbum);
   category_vector.push_back(kAlbumCategoryFolder);
   category_vector.push_back(kAlbumCategoryAlbum);
 
   std::vector<double> date_vector;
   date_vector.push_back(0.0);
   date_vector.push_back(0.0);
@@ skipping 130 matching lines @@
   EXPECT_EQ(test_folder_1_path.AppendASCII("InBoth.jpg"),
             (*album_2_images)["InBoth.jpg"]);
   EXPECT_NE(album_2_images->end(),
             album_2_images->find("InSecondAlbumOnly.jpg"));
   EXPECT_EQ(test_folder_1_path.AppendASCII("InSecondAlbumOnly.jpg"),
             (*album_2_images)["InSecondAlbumOnly.jpg"]);
 }
 
 }  // namespace
 
+class TestPicasaDataProvider : public PicasaDataProvider {
+ public:
+  explicit TestPicasaDataProvider(const base::FilePath& database_path)
+      : PicasaDataProvider(database_path) {
+  }
+
+  virtual ~TestPicasaDataProvider() {}
+
+  // Simulates the actual writing process of moving all the database files
+  // from the temporary directory to the database directory in a loop.
+  void MoveTempFilesToDatabase() {
+    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+
+    base::FileEnumerator file_enumerator(
+        database_path_.DirName().AppendASCII(kPicasaTempDirName),
+        false /* recursive */,
+        base::FileEnumerator::FILES);
+
+    for (base::FilePath src_path = file_enumerator.Next(); !src_path.empty();
+         src_path = file_enumerator.Next()) {
+      ASSERT_TRUE(
+          base::Move(src_path, database_path_.Append(src_path.BaseName())));
+    }
+  }
+
+  void SetInvalidateCallback(const base::Closure& callback) {
+    DCHECK(invalidate_callback_.is_null());
+    invalidate_callback_ = callback;
+  }
+
+  virtual void InvalidateData() OVERRIDE {
+    PicasaDataProvider::InvalidateData();
+
+    if (!invalidate_callback_.is_null()) {
+      invalidate_callback_.Run();
+      invalidate_callback_.Reset();
+    }
+  }
+
+  void SetAlbumMapsForTesting(const AlbumMap& album_map,
+                              const AlbumMap& folder_map) {
+    album_map_ = album_map;
+    folder_map_ = folder_map;
+  }
+
+ private:
+  base::Closure invalidate_callback_;
+};
+
 class PicasaDataProviderTest : public InProcessBrowserTest {
  public:
   PicasaDataProviderTest() : test_helper_(kPicasaAlbumTableName) {}
   virtual ~PicasaDataProviderTest() {}
 
  protected:
   // Runs on the MediaTaskRunner and designed to be overridden by subclasses.
   virtual void InitializeTestData() {}
 
   void RunTest() {
@@ skipping 31 matching lines @@
         FROM_HERE,
         base::Bind(&PicasaDataProviderTest::DestructDataProviderThenQuit,
                    base::Unretained(this)));
   }
 
   const base::FilePath& test_folder_1_path() { return test_folder_1_.path(); }
   const base::FilePath& test_folder_2_path() { return test_folder_2_.path(); }
 
   PmpTestHelper* test_helper() { return &test_helper_; }
 
-  PicasaDataProvider* data_provider() const {
+  TestPicasaDataProvider* data_provider() const {
     return picasa_data_provider_.get();
   }
 
  private:
+  virtual PmpTestHelper::ColumnFileDestination GetColumnFileDestination() {
+    return PmpTestHelper::DATABASE_DIRECTORY;
+  }
+
   void SetupFoldersAndDataProvider() {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
     ASSERT_TRUE(test_folder_1_.CreateUniqueTempDir());
     ASSERT_TRUE(test_folder_2_.CreateUniqueTempDir());
-    ASSERT_TRUE(test_helper_.Init());
-    picasa_data_provider_.reset(
-        new PicasaDataProvider(test_helper_.GetTempDirPath()));
+    ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
+    ASSERT_TRUE(test_helper_.Init(GetColumnFileDestination()));
+    picasa_data_provider_.reset(new TestPicasaDataProvider(
+        test_helper_.GetDatabaseDirPath()));
   }
 
   virtual void StartTestOnMediaTaskRunner() {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
     data_provider()->RefreshData(
         RequestedDataType(),
         base::Bind(&PicasaDataProviderTest::VerifyRefreshResults,
                    base::Unretained(this)));
   }
 
   void DestructDataProviderThenQuit() {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
     picasa_data_provider_.reset();
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE, quit_closure_);
   }
 
   base::ScopedTempDir test_folder_1_;
   base::ScopedTempDir test_folder_2_;
+  base::ScopedTempDir database_dir_;
 
   PmpTestHelper test_helper_;
-  scoped_ptr<PicasaDataProvider> picasa_data_provider_;
+  scoped_ptr<TestPicasaDataProvider> picasa_data_provider_;
 
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(PicasaDataProviderTest);
 };
 
 class PicasaDataProviderNoDatabaseGetListTest : public PicasaDataProviderTest {
  protected:
   virtual PicasaDataProvider::DataType RequestedDataType() const OVERRIDE {
     return PicasaDataProvider::LIST_OF_ALBUMS_AND_FOLDERS_DATA;
@@ skipping 149 matching lines @@
 
   int list_callbacks_called_;
   int albums_images_callbacks_called_;
 };
 
 IN_PROC_BROWSER_TEST_F(PicasaDataProviderMultipleMixedCallbacksTest,
                        MultipleMixedCallbacks) {
   RunTest();
 }
 
-class PicasaDataProviderInvalidateSimpleTest : public PicasaDataProviderTest {
+class PicasaDataProviderFileWatcherInvalidateTest
+    : public PicasaDataProviderGetListTest {
  protected:
-  virtual void FirstListCallback(bool parse_success) {
+  virtual void ListCallback(bool parse_success) {
     ASSERT_FALSE(parse_success);
-    WriteTestAlbumTable(
-        test_helper(), test_folder_1_path(), test_folder_2_path());
 
-    // TODO(tommycli): Remove this line once database is under file watch.
-    data_provider()->InvalidateData();
+    // Validate the list after the file move triggers an invalidate.
+    data_provider()->SetInvalidateCallback(base::Bind(
+        &PicasaDataProvider::RefreshData,
+        base::Unretained(data_provider()),
+        RequestedDataType(),
+        base::Bind(
+            &PicasaDataProviderFileWatcherInvalidateTest::VerifyRefreshResults,
+            base::Unretained(this))));
 
-    // Have to post this, otherwise this will run the callback immediately.
-    MediaFileSystemBackend::MediaTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &PicasaDataProvider::RefreshData,
-            base::Unretained(data_provider()),
-            RequestedDataType(),
-            base::Bind(
-                &PicasaDataProviderInvalidateSimpleTest::SecondListCallback,
-                base::Unretained(this))));
+    data_provider()->MoveTempFilesToDatabase();
   }
 
-  virtual void SecondListCallback(bool parse_success) {
-    ASSERT_TRUE(parse_success);
-    VerifyAlbumTable(
-        data_provider(), test_folder_1_path(), test_folder_2_path());
-    TestDone();
+ private:
+  virtual PmpTestHelper::ColumnFileDestination
+  GetColumnFileDestination() OVERRIDE {
+    return PmpTestHelper::TEMPORARY_DIRECTORY;
   }
 
-  virtual PicasaDataProvider::DataType RequestedDataType() const OVERRIDE {
-    return PicasaDataProvider::ALBUMS_IMAGES_DATA;
+  virtual void StartTestOnMediaTaskRunner() OVERRIDE {
+    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+
+    // Refresh before moving album table to database dir, guaranteeing failure.
+    data_provider()->RefreshData(
+        RequestedDataType(),
+        base::Bind(
+            &PicasaDataProviderFileWatcherInvalidateTest::ListCallback,
+            base::Unretained(this)));
   }
+};
+
+IN_PROC_BROWSER_TEST_F(PicasaDataProviderFileWatcherInvalidateTest,
+                       FileWatcherInvalidateTest) {
+  RunTest();
+}
+
+class PicasaDataProviderInvalidateInflightTableReaderTest
+    : public PicasaDataProviderGetListTest {
+ protected:
+  // Don't write the database files until later.
+  virtual void InitializeTestData() OVERRIDE {}
 
  private:
   virtual void StartTestOnMediaTaskRunner() OVERRIDE {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
-    data_provider()->RefreshData(
-        RequestedDataType(),
-        base::Bind(&PicasaDataProviderInvalidateSimpleTest::FirstListCallback,
-                   base::Unretained(this)));
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(PicasaDataProviderInvalidateSimpleTest,
-                       InvalidateSimpleTest) {
-  RunTest();
-}
-
-class PicasaDataProviderInvalidateInflightTableReaderTest
-    : public PicasaDataProviderGetListTest {
- private:
-  virtual void StartTestOnMediaTaskRunner() OVERRIDE {
-    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
-
-    // Temporarily empty the database path to guarantee that the first utility
-    // process will fail to read the database.
-    data_provider()->SetDatabasePathForTesting(base::FilePath());
+    // Refresh before the database files have been written.
+    // This is guaranteed to fail to read the album table.
     data_provider()->RefreshData(
         RequestedDataType(),
         base::Bind(&PicasaDataProviderInvalidateInflightTableReaderTest::
                        VerifyRefreshResults,
                    base::Unretained(this)));
 
-    // Now restore the database path and invalidate the inflight table reader.
-    data_provider()->SetDatabasePathForTesting(test_helper()->GetTempDirPath());
+    // Now write the album table and invalidate the inflight table reader.
+    PicasaDataProviderGetListTest::InitializeTestData();
     data_provider()->InvalidateData();
 
     // VerifyRefreshResults callback should receive correct results now.
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PicasaDataProviderInvalidateInflightTableReaderTest,
                        InvalidateInflightTableReaderTest) {
   RunTest();
 }
 
 class PicasaDataProviderInvalidateInflightAlbumsIndexerTest
     : public PicasaDataProviderGetAlbumsImagesTest {
  protected:
   virtual void ListCallback(bool parse_success) {
     ASSERT_TRUE(parse_success);
 
     // Empty the album maps to guarantee that the first utility process will
-    // give incorrect results.
+    // fail to get the correct albums-images index.
     data_provider()->SetAlbumMapsForTesting(AlbumMap(), AlbumMap());
     data_provider()->RefreshData(
         PicasaDataProvider::ALBUMS_IMAGES_DATA,
         base::Bind(&PicasaDataProviderInvalidateInflightAlbumsIndexerTest::
                        VerifyRefreshResults,
                    base::Unretained(this)));
 
     // Now invalidate all the data. The album maps will be re-read.
     data_provider()->InvalidateData();
 
@@ skipping 11 matching lines @@
                    base::Unretained(this)));
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PicasaDataProviderInvalidateInflightAlbumsIndexerTest,
                        InvalidateInflightAlbumsIndexerTest) {
   RunTest();
 }
 
 }  // namespace picasa