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

chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider.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 "chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
-#include "base/callback.h"
+#include "base/bind_helpers.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/fileapi/safe_picasa_album_table_reader.h"
+#include "chrome/browser/media_galleries/fileapi/safe_picasa_albums_indexer.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
 using chrome::MediaFileSystemBackend;
 
 namespace picasa {
 
 PicasaDataProvider::PicasaDataProvider(const base::FilePath& database_path)
     : database_path_(database_path),
-      needs_refresh_(true),
+      data_state_(STALE_DATA_STATE),
       weak_factory_(this) {
 }
 
 PicasaDataProvider::~PicasaDataProvider() {}
 
-void PicasaDataProvider::RefreshData(const base::Closure& ready_callback) {
+void PicasaDataProvider::RefreshData(
+    DataType needed_data,
+    const base::Closure& ready_callback) {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   // TODO(tommycli): Need to watch the database_path_ folder and handle
   // rereading the data when it changes.
-  if (!needs_refresh_) {
-    ready_callback.Run();
-    return;
+
+  switch (needed_data) {
+    case ALBUM_LIST_DATA:
+      EnsureAlbumListRefreshed(ready_callback);
+      break;
+    case ALBUMS_IMAGES_DATA:
+      EnsureAlbumsImagesRefreshed(ready_callback);
+      break;
+    default:
+      NOTREACHED();
   }
-
-  needs_refresh_ = false;
-  album_table_reader_ = new SafePicasaAlbumTableReader(
-      AlbumTableFiles(database_path_),
-      base::Bind(&PicasaDataProvider::OnDataRefreshed,
-                 weak_factory_.GetWeakPtr(),
-                 ready_callback));
-  album_table_reader_->Start();
 }
 
 scoped_ptr<AlbumMap> PicasaDataProvider::GetFolders() {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   return make_scoped_ptr(new AlbumMap(folder_map_));
 }
 
 scoped_ptr<AlbumMap> PicasaDataProvider::GetAlbums() {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   return make_scoped_ptr(new AlbumMap(album_map_));
 }
 
-void PicasaDataProvider::OnDataRefreshed(
-    const base::Closure& ready_callback,
+scoped_ptr<AlbumImagesMap> PicasaDataProvider::GetAlbumsImages() {
+  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  return make_scoped_ptr(new AlbumImagesMap(albums_images_));
+}
+
+void PicasaDataProvider::InvalidateData() {
+  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  DCHECK(!(album_table_reader_ && albums_indexer_));
+
+  // Set data state to stale and ignore responses from any in-flight processes.
+  // TODO(tommycli): Implement and call Cancel function for these
+  // UtilityProcessHostClients to actually kill the in-flight processes.
+  data_state_ = STALE_DATA_STATE;
+  album_table_reader_ = NULL;
+  albums_indexer_ = NULL;
+
+  if (!albums_indexer_ready_callbacks_.empty()) {
+    StartAlbumListRefreshIfNecessary();
+    album_list_ready_callbacks_.push(
+        base::Bind(&PicasaDataProvider::StartAlbumsImagesRefreshIfNecessary,

[vandebo (ex-Chrome), 2013/07/11 23:22:37]

You could end up with multiple copies of this callback in
album_list_ready_callbacks_

[tommycli, 2013/07/12 01:37:48]

Done.

+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+
+  if (!album_list_ready_callbacks_.empty()) {
+    StartAlbumListRefreshIfNecessary();
+    return;
+  }
+}
+
+void PicasaDataProvider::EnsureAlbumListRefreshed(
+    const base::Closure& ready_callback) {
+  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  switch (data_state_) {
+    case STALE_DATA_STATE:
+      StartAlbumListRefreshIfNecessary();
+      album_list_ready_callbacks_.push(ready_callback);
+      break;
+    case ALBUM_LIST_FRESH_STATE:
+    case ALBUMS_IMAGES_FRESH_STATE:
+      ready_callback.Run();
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void PicasaDataProvider::EnsureAlbumsImagesRefreshed(
+    const base::Closure& ready_callback) {
+  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  switch (data_state_) {
+    case STALE_DATA_STATE:
+      StartAlbumListRefreshIfNecessary();
+      album_list_ready_callbacks_.push(
+          base::Bind(&PicasaDataProvider::StartAlbumsImagesRefreshIfNecessary,
+                     weak_factory_.GetWeakPtr()));
+      albums_indexer_ready_callbacks_.push(ready_callback);
+      break;
+    case ALBUM_LIST_FRESH_STATE:
+      StartAlbumsImagesRefreshIfNecessary();
+      albums_indexer_ready_callbacks_.push(ready_callback);
+      break;
+    case ALBUMS_IMAGES_FRESH_STATE:
+      ready_callback.Run();
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void PicasaDataProvider::StartAlbumListRefreshIfNecessary() {
+  if (!album_table_reader_)
+    return;
+  album_table_reader_ = new SafePicasaAlbumTableReader(
+      AlbumTableFiles(database_path_),
+      base::Bind(&PicasaDataProvider::OnAlbumListRefreshed,
+                 weak_factory_.GetWeakPtr()));
+  album_table_reader_->Start();
+}
+
+void PicasaDataProvider::StartAlbumsImagesRefreshIfNecessary() {
+  if (!albums_indexer_)
+    return;
+  albums_indexer_ = new SafePicasaAlbumsIndexer(
+      album_map_,
+      folder_map_,
+      base::Bind(&PicasaDataProvider::OnAlbumsIndexerDone,
+                 weak_factory_.GetWeakPtr()));
+  albums_indexer_->Start();
+}
+
+void PicasaDataProvider::OnAlbumListRefreshed(
+    scoped_refptr<SafePicasaAlbumTableReader> reader,
     bool parse_success,
     const std::vector<AlbumInfo>& albums,
     const std::vector<AlbumInfo>& folders) {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  // If the reader has already been deemed stale, ignore the result.
+  if (reader != album_table_reader_)
+    return;
+
   if (parse_success) {
+    album_map_.clear();
+    folder_map_.clear();
     UniquifyNames(albums, &album_map_);
     UniquifyNames(folders, &folder_map_);
   }
-  ready_callback.Run();
+
+  data_state_ = ALBUM_LIST_FRESH_STATE;
+
+  while (!album_list_ready_callbacks_.empty()) {
+    album_list_ready_callbacks_.front().Run();
+    album_list_ready_callbacks_.pop();
+  }
+}
+
+void PicasaDataProvider::OnAlbumsIndexerDone(
+    scoped_refptr<SafePicasaAlbumsIndexer> indexer,
+    const picasa::AlbumImagesMap& albums_images) {
+  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  // If the indexer has already been deemed stale, ignore the result.
+  if (indexer != albums_indexer_)
+    return;
+
+  albums_images_ = albums_images;
+
+  data_state_ = ALBUMS_IMAGES_FRESH_STATE;
+
+  while (!albums_indexer_ready_callbacks_.empty()) {
+    albums_indexer_ready_callbacks_.front().Run();
+    albums_indexer_ready_callbacks_.pop();
+  }
 }
 
 // static
 std::string PicasaDataProvider::DateToPathString(const base::Time& time) {
   base::Time::Exploded exploded_time;
   time.LocalExplode(&exploded_time);
 
   // TODO(tommycli): Investigate better localization and persisting which locale
   // we use to generate these unique names.
   return base::StringPrintf("%04d-%02d-%02d", exploded_time.year,
@@ skipping 23 matching lines @@
     if (total_counts[name] != 1) {
       name = base::StringPrintf("%s (%d)", name.c_str(),
                                 ++current_counts[name]);
     }
 
     result_map->insert(std::pair<std::string, AlbumInfo>(name, info_list[i]));
   }
 }
 
 }  // namespace picasa