Media Galleries API: Audio/Video attached pictures support.

chrome/utility/media_galleries/media_metadata_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/media_metadata_parser.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "chrome/utility/media_galleries/image_metadata_extractor.h"
 #include "media/base/audio_video_metadata_extractor.h"
 #include "media/base/data_source.h"
+#include "net/base/mime_sniffer.h"
 
 namespace MediaGalleries = extensions::api::media_galleries;
 
 namespace metadata {
 
 namespace {
 
 void SetStringScopedPtr(const std::string& value,
                         scoped_ptr<std::string>* destination) {
   DCHECK(destination);
@@ skipping 14 matching lines @@
 }
 
 void SetBoolScopedPtr(bool value, scoped_ptr<bool>* destination) {
   DCHECK(destination);
   destination->reset(new bool(value));
 }
 
 // This runs on |media_thread_|, as the underlying FFmpeg operation is
 // blocking, and the utility thread must not be blocked, so the media file
 // bytes can be sent from the browser process to the utility process.
-scoped_ptr<MediaMetadataParser::MediaMetadata> ParseAudioVideoMetadata(
-    media::DataSource* source,
-    scoped_ptr<MediaMetadataParser::MediaMetadata> metadata) {
+void ParseAudioVideoMetadata(
+    media::DataSource* source, bool get_attached_pictures,
+    MediaMetadataParser::MediaMetadata* metadata,
+    std::vector<std::string>* attached_pictures_bytes,

[vandebo (ex-Chrome), 2014/04/23 23:22:45]

Maybe there should be a struct ThumbnailData {
std::string type;
std::string data;
};
Then you can just deal with std::vector<ThumbnailData> ?

[tommycli, 2014/04/29 00:15:51]

Done.

+    std::vector<std::string>* attached_pictures_types) {
   DCHECK(source);
-  DCHECK(metadata.get());
+  DCHECK(metadata);
   media::AudioVideoMetadataExtractor extractor;
 
-  if (!extractor.Extract(source))
-    return metadata.Pass();
+  if (!extractor.Extract(source, get_attached_pictures))
+    return;
 
   if (extractor.duration() >= 0)
     metadata->duration.reset(new double(extractor.duration()));
 
   if (extractor.height() >= 0 && extractor.width() >= 0) {
     metadata->height.reset(new int(extractor.height()));
     metadata->width.reset(new int(extractor.width()));
   }
 
   SetStringScopedPtr(extractor.artist(), &metadata->artist);
@@ skipping 18 matching lines @@
     for (std::map<std::string, std::string>::const_iterator tag_it =
              it->tags.begin();
          tag_it != it->tags.end(); ++tag_it) {
       stream_info->tags.additional_properties.SetString(tag_it->first,
                                                         tag_it->second);
     }
 
     metadata->raw_tags.push_back(stream_info);
   }
 
-  return metadata.Pass();
+  if (get_attached_pictures) {
+    DCHECK(attached_pictures_bytes);
+    DCHECK(attached_pictures_types);
+    *attached_pictures_bytes = extractor.attached_pictures_bytes();
+    for (std::vector<std::string>::const_iterator it =
+             attached_pictures_bytes->begin();
+         it != attached_pictures_bytes->end(); ++it) {
+      std::string type;
+      net::SniffMimeTypeFromLocalData(it->c_str(), it->length(), &type);
+      attached_pictures_types->push_back(type);
+    }
+  }
+}
+
+void FinishParseAudioVideoMetadata(
+    MediaMetadataParser::MetadataCallback callback,

[vandebo (ex-Chrome), 2014/04/23 23:22:45]

Is this needed? Can you just bind to the callback instead?

[tommycli, 2014/04/29 00:15:51]

Needed so that the callback could base::Owned the data. The callback takes a
reference rather than a pointer.

+    scoped_ptr<MediaMetadataParser::MediaMetadata> metadata,
+    std::vector<std::string>* attached_pictures_bytes,
+    std::vector<std::string>* attached_pictures_types) {
+  DCHECK(!callback.is_null());
+  DCHECK(metadata.get());
+  DCHECK(attached_pictures_bytes);
+  DCHECK(attached_pictures_types);
+
+  callback.Run(metadata.Pass(), *attached_pictures_bytes,
+               *attached_pictures_types);
 }
 
 void FinishParseImageMetadata(
     ImageMetadataExtractor* extractor,
     scoped_ptr<MediaMetadataParser::MediaMetadata> metadata,
     MediaMetadataParser::MetadataCallback callback,
     bool extract_success) {
   DCHECK(extractor);
   DCHECK(metadata.get());
 
   if (!extract_success) {
-    callback.Run(metadata.Pass());
+    callback.Run(metadata.Pass(), std::vector<std::string>(),
+                 std::vector<std::string>());
     return;
   }
 
   SetIntScopedPtr(extractor->height(), &metadata->height);
   SetIntScopedPtr(extractor->width(), &metadata->width);
 
   SetIntScopedPtr(extractor->rotation(), &metadata->rotation);
 
   SetDoubleScopedPtr(extractor->x_resolution(), &metadata->x_resolution);
   SetDoubleScopedPtr(extractor->y_resolution(), &metadata->y_resolution);
   SetBoolScopedPtr(extractor->flash_fired(), &metadata->flash_fired);
   SetStringScopedPtr(extractor->camera_make(), &metadata->camera_make);
   SetStringScopedPtr(extractor->camera_model(), &metadata->camera_model);
   SetDoubleScopedPtr(extractor->exposure_time_sec(),
                      &metadata->exposure_time_seconds);
 
   SetDoubleScopedPtr(extractor->f_number(), &metadata->f_number);
   SetDoubleScopedPtr(extractor->focal_length_mm(), &metadata->focal_length_mm);
   SetDoubleScopedPtr(extractor->iso_equivalent(), &metadata->iso_equivalent);
 
-  callback.Run(metadata.Pass());
+  callback.Run(metadata.Pass(), std::vector<std::string>(),
+               std::vector<std::string>());
 }
 
 }  // namespace
 
 MediaMetadataParser::MediaMetadataParser(media::DataSource* source,
-                                         const std::string& mime_type)
+                                         const std::string& mime_type,
+                                         bool get_attached_pictures)
     : source_(source),
-      mime_type_(mime_type) {
+      mime_type_(mime_type),
+      get_attached_pictures_(get_attached_pictures) {
 }
 
 MediaMetadataParser::~MediaMetadataParser() {}
 
 void MediaMetadataParser::Start(const MetadataCallback& callback) {
   scoped_ptr<MediaMetadata> metadata(new MediaMetadata);
   metadata->mime_type = mime_type_;
 
   if (StartsWithASCII(mime_type_, "audio/", true) ||
       StartsWithASCII(mime_type_, "video/", true)) {
+    std::vector<std::string>* attached_pictures_bytes =
+        new std::vector<std::string>;
+    std::vector<std::string>* attached_pictures_types =
+        new std::vector<std::string>;
+
     media_thread_.reset(new base::Thread("media_thread"));
     CHECK(media_thread_->Start());
-    base::PostTaskAndReplyWithResult(
-        media_thread_->message_loop_proxy(),
+    media_thread_->message_loop_proxy()->PostTaskAndReply(
         FROM_HERE,
-        base::Bind(&ParseAudioVideoMetadata, source_, base::Passed(&metadata)),
-        callback);
+        base::Bind(&ParseAudioVideoMetadata, source_, get_attached_pictures_,
+                   metadata.get(), attached_pictures_bytes,
+                   attached_pictures_types),
+        base::Bind(&FinishParseAudioVideoMetadata, callback,
+                   base::Passed(&metadata),
+                   base::Owned(attached_pictures_bytes),
+                   base::Owned(attached_pictures_types)));
     return;
   }
 
   if (StartsWithASCII(mime_type_, "image/", true)) {
     ImageMetadataExtractor* extractor = new ImageMetadataExtractor;
     extractor->Extract(
         source_,
         base::Bind(&FinishParseImageMetadata, base::Owned(extractor),
                    base::Passed(&metadata), callback));
     return;
   }
 
-  // TODO(tommycli): Implement for image mime types.
-  callback.Run(metadata.Pass());
+  callback.Run(metadata.Pass(), std::vector<std::string>(),
+               std::vector<std::string>());
 }
 
 }  // namespace metadata