Media Galleries API Picasa: Make PicasaDataProvider handle async PMP and INI parsing robustly.

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/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.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"
@@ skipping 121 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 SynchronouslyRunOnMediaTaskRunner(const base::Closure& closure) {
+  base::RunLoop loop;
+  chrome::MediaFileSystemBackend::MediaTaskRunner()->PostTaskAndReply(
+      FROM_HERE,
+      closure,
+      base::Bind(&base::RunLoop::Quit, base::Unretained(&loop)));

[vandebo (ex-Chrome), 2013/08/27 04:29:04]

loop::QuitClosure()

[tommycli, 2013/08/27 18:39:18]

Done.

+  loop.Run();
+}
+
 }  // namespace
 
-class TestPicasaDataProvider : public PicasaDataProvider {
- public:
-  TestPicasaDataProvider()
-      : PicasaDataProvider(base::FilePath(FILE_PATH_LITERAL("Fake"))),
-        initialized_(false) {
-  }
-
-  virtual ~TestPicasaDataProvider() {}
-
-  virtual void RefreshData(const base::Closure& ready_callback) OVERRIDE {
-    DCHECK(initialized_);
-    ready_callback.Run();
-  }
-
-  void Init(const std::vector<AlbumInfo>& albums,
-            const std::vector<AlbumInfo>& folders) {
-    UniquifyNames(albums, &album_map_);
-    UniquifyNames(folders, &folder_map_);
-    initialized_ = true;
-  }
-
- private:
-  bool initialized_;
-};
-
 class TestPicasaFileUtil : public PicasaFileUtil {
  public:
   TestPicasaFileUtil(chrome::MediaPathFilter* media_path_filter,
                      PicasaDataProvider* data_provider)
       : PicasaFileUtil(media_path_filter),
         data_provider_(data_provider) {
   }
   virtual ~TestPicasaFileUtil() {}
  private:
   virtual PicasaDataProvider* GetDataProvider() OVERRIDE {
@@ skipping 31 matching lines @@
       : io_thread_(content::BrowserThread::IO, &message_loop_) {
   }
   virtual ~PicasaFileUtilTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
 
     scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
         new quota::MockSpecialStoragePolicy();
 
+    SynchronouslyRunOnMediaTaskRunner(base::Bind(
+        &PicasaFileUtilTest::SetUpOnMediaTaskRunner, base::Unretained(this)));
+
     media_path_filter_.reset(new chrome::MediaPathFilter());
-    picasa_data_provider_.reset(new TestPicasaDataProvider());
 
     ScopedVector<fileapi::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestMediaFileSystemBackend(
         profile_dir_.path(),
         new TestPicasaFileUtil(media_path_filter_.get(),
                                picasa_data_provider_.get())));
 
     file_system_context_ = new fileapi::FileSystemContext(
         base::MessageLoopProxy::current().get(),
         base::MessageLoopProxy::current().get(),
         fileapi::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy.get(),
         NULL,
         additional_providers.Pass(),
         profile_dir_.path(),
         fileapi::CreateAllowFileAccessOptions());
   }
 
+  virtual void TearDown() OVERRIDE {
+    SynchronouslyRunOnMediaTaskRunner(
+        base::Bind(&PicasaFileUtilTest::TearDownOnMediaTaskRunner,
+                   base::Unretained(this)));
+  }
+
  protected:
+  void SetUpOnMediaTaskRunner() {
+    picasa_data_provider_.reset(new PicasaDataProvider(base::FilePath()));
+  }
+
+  void TearDownOnMediaTaskRunner() {
+    picasa_data_provider_.reset();
+  }
+
+  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) {
     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());
     }
-    picasa_data_provider_->Init(std::vector<AlbumInfo>(), folders);
+
+    SetupDataProvider(
+        picasa_data_provider_.get(), std::vector<AlbumInfo>(), folders);
   }
 
   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 59 matching lines @@
     return file_system_context_;
   }
 
  private:
   base::MessageLoop message_loop_;
   content::TestBrowserThread io_thread_;
 
   base::ScopedTempDir profile_dir_;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_ptr<PicasaDataProvider> picasa_data_provider_;
   scoped_ptr<chrome::MediaPathFilter> media_path_filter_;
-  scoped_ptr<TestPicasaDataProvider> picasa_data_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(PicasaFileUtilTest);
 };
 
 TEST_F(PicasaFileUtilTest, DateFormat) {
   base::Time::Exploded exploded_shortmonth = { 2013, 4, 0, 16, 0, 0, 0, 0 };
   base::Time shortmonth = base::Time::FromLocalExploded(exploded_shortmonth);
 
   base::Time::Exploded exploded_shortday = { 2013, 11, 0, 3, 0, 0, 0, 0 };
   base::Time shortday = base::Time::FromLocalExploded(exploded_shortday);
@@ skipping 121 matching lines @@
         new TestFolder(base::StringPrintf("folder-%05d", i),
                        date,
                        base::StringPrintf("uid%05d", i), i % 5, i % 3));
   }
 
   SetupFolders(&test_folders);
   VerifyFolderDirectoryList(test_folders);
 }
 
 }  // namespace picasa