Remove call to IsRunningSequenceOnCurrentThread() in media_file_system_backend.cc

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"
@@ skipping 181 matching lines @@
       base::Bind(&ITunesDataProvider::OnLibraryParsed,
                  weak_factory_.GetWeakPtr(),
                  ready_callback));
 }
 
 const base::FilePath& ITunesDataProvider::auto_add_path() const {
   return auto_add_path_;
 }
 
 bool ITunesDataProvider::KnownArtist(const ArtistName& artist) const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   return base::ContainsKey(library_, artist);
 }
 
 bool ITunesDataProvider::KnownAlbum(const ArtistName& artist,
                                     const AlbumName& album) const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   Library::const_iterator library_it = library_.find(artist);
   if (library_it == library_.end())
     return false;
   return base::ContainsKey(library_it->second, album);
 }
 
 base::FilePath ITunesDataProvider::GetTrackLocation(
     const ArtistName& artist, const AlbumName& album,
     const TrackName& track) const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   Library::const_iterator library_it = library_.find(artist);
   if (library_it == library_.end())
     return base::FilePath();
 
   Artist::const_iterator artist_it = library_it->second.find(album);
   if (artist_it == library_it->second.end())
     return base::FilePath();
 
   Album::const_iterator album_it = artist_it->second.find(track);
   if (album_it == artist_it->second.end())
     return base::FilePath();
   return album_it->second;
 }
 
 std::set<ITunesDataProvider::ArtistName>
 ITunesDataProvider::GetArtistNames() const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   std::set<ArtistName> result;
   Library::const_iterator it;
   for (it = library_.begin(); it != library_.end(); ++it) {
     result.insert(it->first);
   }
   return result;
 }
 
 std::set<ITunesDataProvider::AlbumName> ITunesDataProvider::GetAlbumNames(
     const ArtistName& artist) const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   std::set<AlbumName> result;
   Library::const_iterator artist_lookup = library_.find(artist);
   if (artist_lookup == library_.end())
     return result;
 
   const Artist& artist_entry = artist_lookup->second;
   Artist::const_iterator it;
   for (it = artist_entry.begin(); it != artist_entry.end(); ++it) {
     result.insert(it->first);
   }
   return result;
 }
 
 ITunesDataProvider::Album ITunesDataProvider::GetAlbum(
     const ArtistName& artist, const AlbumName& album) const {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   DCHECK(valid());
   Album result;
   Library::const_iterator artist_lookup = library_.find(artist);
   if (artist_lookup != library_.end()) {
     Artist::const_iterator album_lookup = artist_lookup->second.find(album);
     if (album_lookup != artist_lookup->second.end())
       result = album_lookup->second;
   }
   return result;
 }
 
 void ITunesDataProvider::OnLibraryParsed(const ReadyCallback& ready_callback,
                                          bool result,
                                          const parser::Library& library) {
-  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
+  MediaFileSystemBackend::AssertCurrentlyOnMediaSequence();
   set_valid(result);
   if (valid()) {
     library_.clear();
     for (parser::Library::const_iterator artist_it = library.begin();
          artist_it != library.end();
          ++artist_it) {
       std::string artist_name = SanitizeName(artist_it->first);
       for (parser::Albums::const_iterator album_it = artist_it->second.begin();
            album_it != artist_it->second.end();
            ++album_it) {
         std::string album_name = SanitizeName(album_it->first);
         library_[artist_name][album_name] =
             MakeUniqueTrackNames(album_it->second);
       }
     }
   }
   ready_callback.Run(valid());
 }
 
 }  // namespace itunes