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"
@@ skipping 152 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:
   void SetupFoldersAndDataProvider() {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
     ASSERT_TRUE(test_folder_1_.CreateUniqueTempDir());
     ASSERT_TRUE(test_folder_2_.CreateUniqueTempDir());
+    ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(test_helper_.Init());
-    picasa_data_provider_.reset(
-        new PicasaDataProvider(test_helper_.GetTempDirPath()));
+    picasa_data_provider_.reset(new TestPicasaDataProvider(
+        test_helper_.GetDatabaseDirPath()));
   }
 
   virtual void StartTestOnMediaTaskRunner() {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
+    data_provider()->MoveTempFilesToDatabase();
+
     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 116 matching lines @@
   void CheckTestDone() {
     ASSERT_LE(list_callbacks_called_, 2);
     ASSERT_LE(albums_images_callbacks_called_, 2);
     if (list_callbacks_called_ == 2 && albums_images_callbacks_called_ == 2)
       TestDone();
   }
 
   virtual void StartTestOnMediaTaskRunner() OVERRIDE {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
+    data_provider()->MoveTempFilesToDatabase();
+
     data_provider()->RefreshData(
         PicasaDataProvider::LIST_OF_ALBUMS_AND_FOLDERS_DATA,
         base::Bind(&PicasaDataProviderMultipleMixedCallbacksTest::ListCallback,
                    base::Unretained(this),
                    1));
     data_provider()->RefreshData(
         PicasaDataProvider::ALBUMS_IMAGES_DATA,
         base::Bind(
             &PicasaDataProviderMultipleMixedCallbacksTest::AlbumsImagesCallback,
             base::Unretained(this),
@@ skipping 13 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))));
-  }
-
-  virtual void SecondListCallback(bool parse_success) {
-    ASSERT_TRUE(parse_success);
-    VerifyAlbumTable(
-        data_provider(), test_folder_1_path(), test_folder_2_path());
-    TestDone();
-  }
-
-  virtual PicasaDataProvider::DataType RequestedDataType() const OVERRIDE {
-    return PicasaDataProvider::ALBUMS_IMAGES_DATA;
+    data_provider()->MoveTempFilesToDatabase();
   }
 
  private:
   virtual void StartTestOnMediaTaskRunner() OVERRIDE {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
+    // Refresh before moving album table to database dir, guaranteeing failure.
     data_provider()->RefreshData(
         RequestedDataType(),
-        base::Bind(&PicasaDataProviderInvalidateSimpleTest::FirstListCallback,
-                   base::Unretained(this)));
+        base::Bind(
+            &PicasaDataProviderFileWatcherInvalidateTest::ListCallback,
+            base::Unretained(this)));
   }
 };
 
-IN_PROC_BROWSER_TEST_F(PicasaDataProviderInvalidateSimpleTest,
-                       InvalidateSimpleTest) {
+IN_PROC_BROWSER_TEST_F(PicasaDataProviderFileWatcherInvalidateTest,
+                       FileWatcherInvalidateTest) {
   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 moved into the database.
+    // 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 move table into database and invalidate the inflight table reader.
+    data_provider()->MoveTempFilesToDatabase();
     data_provider()->InvalidateData();

[vandebo (ex-Chrome), 2013/09/05 16:49:38]

This is tricky again - You should only do one of the two things here.  If you
can ensure that the invalidate from the move will trigger before your first read
finishes (I don't think you can), then you should just move stuff into place. 
If not, the files should already be in place and you can trigger the condition
you're interested in by explicitly invalidating the data.

[tommycli, 2013/09/05 21:37:37]

Done.

 
     // 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();
 
     // VerifyRefreshResults callback should receive correct results now.
   }
 
  private:
   virtual void StartTestOnMediaTaskRunner() OVERRIDE {
     DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
 
+    data_provider()->MoveTempFilesToDatabase();
+
     data_provider()->RefreshData(
         PicasaDataProvider::LIST_OF_ALBUMS_AND_FOLDERS_DATA,
         base::Bind(&PicasaDataProviderInvalidateInflightAlbumsIndexerTest::
                        ListCallback,
                    base::Unretained(this)));
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PicasaDataProviderInvalidateInflightAlbumsIndexerTest,
                        InvalidateInflightAlbumsIndexerTest) {
   RunTest();
 }
 
 }  // namespace picasa