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

chrome/browser/media_galleries/fileapi/itunes_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/itunes_data_provider.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
+#include "chrome/browser/media_galleries/fileapi/data_provider_helper.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "chrome/common/media_galleries/itunes_library.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/icu/source/common/unicode/locid.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 
 using chrome::MediaFileSystemBackend;
 
 namespace itunes {
 
 namespace {
 
-typedef base::Callback<void(scoped_ptr<base::FilePathWatcher> watcher)>
-    FileWatchStartedCallback;
-
 ITunesDataProvider::Album MakeUniqueTrackNames(const parser::Album& album) {
   // TODO(vandebo): It would be nice to ensure that names returned from here
   // are stable, but aside from persisting every name returned, it's not
   // obvious how to do that (without including the track id in every name).
   typedef std::set<const parser::Track*> TrackRefs;
   typedef std::map<ITunesDataProvider::TrackName, TrackRefs> AlbumInfo;
 
   ITunesDataProvider::Album result;
   AlbumInfo duped_tracks;
 
@@ skipping 19 matching lines @@
         base::FilePath unique_name =
             (*track_it)->location.BaseName().InsertBeforeExtensionASCII(id);
         result[unique_name.AsUTF8Unsafe()] = (*track_it)->location;
       }
     }
   }
 
   return result;
 }
 
-// Bounces |path| and |error| to |callback| from the FILE thread to the media
-// task runner.
-void OnLibraryChanged(const base::FilePathWatcher::Callback& callback,
-                      const base::FilePath& path,
-                      bool error) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  MediaFileSystemBackend::MediaTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(callback, path, error));
-}
-
-// The watch has to be started on the FILE thread, and the callback called by
-// the FilePathWatcher also needs to run on the FILE thread.
-void StartLibraryWatchOnFileThread(
-    const base::FilePath& library_path,
-    const FileWatchStartedCallback& watch_started_callback,
-    const base::FilePathWatcher::Callback& library_changed_callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  // The watcher is created on the FILE thread because it is very difficult
-  // to safely pass an already-created member to a different thread.
-  scoped_ptr<base::FilePathWatcher> watcher(new base::FilePathWatcher);
-  bool success = watcher->Watch(
-      library_path, false /*recursive*/,
-      base::Bind(&OnLibraryChanged, library_changed_callback));
-  if (!success)
-    LOG(ERROR) << "Adding watch for " << library_path.value() << " failed";
-  MediaFileSystemBackend::MediaTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(watch_started_callback, base::Passed(&watcher)));
-}
-
 // |result_path| is set if |locale_string| maps to a localized directory name
 // and it exists in the filesystem.
 bool CheckLocaleStringAutoAddPath(
     const base::FilePath& media_path,
     const std::map<std::string, std::string>& localized_dir_names,
     const std::string& locale_string,
     base::FilePath* result_path) {
   DCHECK(!media_path.empty());
   DCHECK(!localized_dir_names.empty());
   DCHECK(!locale_string.empty());
@@ skipping 88 matching lines @@
 
 ITunesDataProvider::ITunesDataProvider(const base::FilePath& library_path)
     : library_path_(library_path),
       auto_add_path_(GetAutoAddPath(library_path)),
       needs_refresh_(true),
       is_valid_(false),
       weak_factory_(this) {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   DCHECK(!library_path_.empty());
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(StartLibraryWatchOnFileThread,
-                 library_path_,
-                 base::Bind(&ITunesDataProvider::OnLibraryWatchStarted,
-                            weak_factory_.GetWeakPtr()),
-                 base::Bind(&ITunesDataProvider::OnLibraryChanged,
-                            weak_factory_.GetWeakPtr())));
+  chrome::StartFilePathWatchOnMediaTaskRunner(
+      library_path_,
+      false /* recursive */,
+      base::Bind(&ITunesDataProvider::OnLibraryWatchStarted,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&ITunesDataProvider::OnLibraryChanged,
+                 weak_factory_.GetWeakPtr()));
 }
 
 ITunesDataProvider::~ITunesDataProvider() {}
 
 // TODO(vandebo): add a file watch that resets |needs_refresh_| when the
 // file changes.
 void ITunesDataProvider::RefreshData(const ReadyCallback& ready_callback) {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   if (!needs_refresh_) {
     ready_callback.Run(is_valid_);
@@ skipping 125 matching lines @@
            ++album_it) {
         library_[artist_it->first][album_it->first] =
             MakeUniqueTrackNames(album_it->second);
       }
     }
   }
   ready_callback.Run(is_valid_);
 }
 
 }  // namespace itunes