[MediaGalleries] iPhoto: Add original file field to the parser. Dedupe album names.

chrome/utility/media_galleries/iphoto_library_parser.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/utility/media_galleries/iphoto_library_parser.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/utility/media_galleries/iapps_xml_utils.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace iphoto {
 
 namespace {
 
 struct PhotoInfo {

[vandebo (ex-Chrome), 2013/10/31 20:53:43]

I think we should remove everything we don't use from this.  I think that's
guid, time, and type.

[Greg Billock, 2013/10/31 22:34:24]

ok

   uint64 id;
   std::string guid;
   base::FilePath location;
+  base::FilePath original_location;
+  base::Time time;
   std::string type;
 };
 
 struct AlbumInfo {
   std::set<uint64> photo_ids;
   std::string name;
   uint64 id;
 };
 
 // Walk through a dictionary filling in |result| with photo information. Return
 // true if at least the id and location were found.
 // In either case, the cursor is advanced out of the dictionary.
 bool GetPhotoInfoFromDict(XmlReader* reader, PhotoInfo* result) {
   DCHECK(result);
   if (reader->NodeName() != "dict")
     return false;
 
   int dict_content_depth = reader->Depth() + 1;
   // Advance past the dict node and into the body of the dictionary.
   if (!reader->Read())
     return false;
 
-  bool found_guid = false;
   bool found_location = false;
-  bool found_type = false;
-  while (reader->Depth() >= dict_content_depth &&
-         !(found_guid && found_location && found_type)) {
+  while (reader->Depth() >= dict_content_depth) {
     if (!iapps::SeekToNodeAtCurrentDepth(reader, "key"))
       break;
     std::string found_key;
     if (!reader->ReadElementContent(&found_key))
       break;
     DCHECK_EQ(dict_content_depth, reader->Depth());
 
     if (found_key == "GUID") {
-      if (found_guid)
-        break;
       if (!iapps::ReadString(reader, &result->guid))
         break;
-      found_guid = true;
     } else if (found_key == "MediaType") {
-      if (found_type)
-        break;
       if (!iapps::ReadString(reader, &result->type))
         break;
-      found_type = true;
     } else if (found_key == "ImagePath") {
       if (found_location)
         break;
       std::string value;
       if (!iapps::ReadString(reader, &value))
         break;
       result->location = base::FilePath(value);
       found_location = true;
+    } else if (found_key == "OriginalPath") {
+      std::string value;
+      if (!iapps::ReadString(reader, &value))
+        break;
+      result->original_location = base::FilePath(value);
+    } else if (found_key == "DateAsTimerIntervalGMT") {
+      std::string value;
+      if (!iapps::ReadString(reader, &value))
+        break;
+      double time_double = 0.0;
+      if (!base::StringToDouble(value, &time_double))
+        break;
+      // Add offset from Mac time (2001-based) to 1970-based.
+      result->time = base::Time::FromDoubleT(time_double + 978307200.0);
     } else {
       if (!iapps::SkipToNextElement(reader))
         break;
       if (!reader->Next())
         break;
     }
   }
 
   // Seek to the end of the dictionary
   while (reader->Depth() >= dict_content_depth)
@@ skipping 134 matching lines @@
       break;
     }
 
     PhotoInfo photo_info;
     photo_info.id = id;
     if (!GetPhotoInfoFromDict(reader, &photo_info)) {
       errors = true;
       break;
     }
 
-    parser::Photo photo(photo_info.id, photo_info.location);
+    parser::Photo photo(photo_info.id, photo_info.location,
+                        photo_info.original_location, photo_info.time);
     all_photos->insert(photo);
   }
 
   return !errors;
 }
 
 }  // namespace
 
 IPhotoLibraryParser::IPhotoLibraryParser() {}
 IPhotoLibraryParser::~IPhotoLibraryParser() {}
@@ skipping 36 matching lines @@
       if (!iapps::SeekToNodeAtCurrentDepth(&reader, "array") ||
           !reader.Read()) {
         continue;
       }
 
       while (iapps::SeekToNodeAtCurrentDepth(&reader, "dict")) {
         AlbumInfo album_info;
         if (GetAlbumInfoFromDict(&reader, &album_info)) {
           parser::Album album;
           album = album_info.photo_ids;
-          // Strip / from album name.
+          // Strip / from album name and dedupe any collisions.
           std::string name;
           ReplaceChars(album_info.name, "//", " ", &name);
-          library_.albums[name] = album;
+          if (!ContainsKey(library_.albums, name)) {
+            library_.albums[name] = album;

[vandebo (ex-Chrome), 2013/10/31 20:53:43]

So first in the xml file wins?  Maybe we should try to do better.

[Greg Billock, 2013/10/31 22:34:24]

Sounds good.

[vandebo (ex-Chrome), 2013/11/01 18:50:33]

Should we keep a separate list of dup album names basenames and add the album id
to all of them?  We could just use 1-n in that case.

+          } else {
+            library_.albums[name+"("+base::Uint64ToString(album_info.id)+")"] =

[vandebo (ex-Chrome), 2013/10/31 20:53:43]

Date might be a more useful uniquifier, is there a field for album date?

[Greg Billock, 2013/10/31 22:34:24]

No, there's no real good signal. There's a GUID, a SongPath, which I'm guessing
is often just the default and not much use, and then the list of IDs. I thought
about counting the number of photos in the album, but then we'd need a dedupe
for our dedupe. Let's just go with this and if we think of something better
it'll be easy to change.

+                album;
+          }
         }
       }
     } else if (found_key == "Master Image List") {
       if (found_photos)
         continue;
       found_photos = true;
       if (!ParseAllPhotos(&reader, &library_.all_photos))
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace iphoto