iTunes artist, album, and track names need to be escaped for slash and colon.

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/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.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;
 
+// Colon and slash are not allowed in filenames, replace them with underscore.
+std::string EscapeBadCharacters(const std::string& input) {
+  std::string result;
+  ReplaceChars(input, ":/", "_", &result);
+  return result;
+}
+
 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;
 
   parser::Album::const_iterator album_it;
   for (album_it = album.begin(); album_it != album.end(); ++album_it) {
     const parser::Track& track = *album_it;
-    std::string name = track.location.BaseName().AsUTF8Unsafe();
+    std::string name =
+        EscapeBadCharacters(track.location.BaseName().AsUTF8Unsafe());
     duped_tracks[name].insert(&track);
   }
 
   for (AlbumInfo::const_iterator name_it = duped_tracks.begin();
        name_it != duped_tracks.end();
        ++name_it) {
     const TrackRefs& track_refs = name_it->second;
     if (track_refs.size() == 1) {
       result[name_it->first] = (*track_refs.begin())->location;
     } else {
       for (TrackRefs::const_iterator track_it = track_refs.begin();
            track_it != track_refs.end();
            ++track_it) {
         std::string id =
             base::StringPrintf(" (%" PRId64 ")", (*track_it)->id);
-        base::FilePath unique_name =
-            (*track_it)->location.BaseName().InsertBeforeExtensionASCII(id);
-        result[unique_name.AsUTF8Unsafe()] = (*track_it)->location;
+        std::string track_name =
+            EscapeBadCharacters((*track_it)->location

[Lei Zhang, 2013/08/29 23:28:38]

Can we use more temp vars so this is easier to read?

[vandebo (ex-Chrome), 2013/08/30 03:48:32]

Done.

+                                .BaseName()
+                                .InsertBeforeExtensionASCII(id)
+                                .AsUTF8Unsafe());
+        result[track_name] = (*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,
@@ skipping 267 matching lines @@
 void ITunesDataProvider::OnLibraryParsed(const ReadyCallback& ready_callback,
                                          bool result,
                                          const parser::Library& library) {
   DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
   is_valid_ = result;
   if (is_valid_) {
     library_.clear();
     for (parser::Library::const_iterator artist_it = library.begin();
          artist_it != library.end();
          ++artist_it) {
+      std::string artist_name = EscapeBadCharacters(artist_it->first);
       for (parser::Albums::const_iterator album_it = artist_it->second.begin();
            album_it != artist_it->second.end();
            ++album_it) {
-        library_[artist_it->first][album_it->first] =
+        std::string album_name = EscapeBadCharacters(album_it->first);
+        library_[artist_name][album_name] =
             MakeUniqueTrackNames(album_it->second);
       }
     }
   }
   ready_callback.Run(is_valid_);
 }
 
 }  // namespace itunes