Reapply "Media Galleries API Metadata: Image metadata"

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/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"
 
 namespace metadata {
 
 namespace {
 
 void SetStringScopedPtr(const std::string& value,
                         scoped_ptr<std::string>* destination) {
+  DCHECK(destination);
   if (!value.empty())
     destination->reset(new std::string(value));
 }
 
 void SetIntScopedPtr(int value, scoped_ptr<int>* destination) {
+  DCHECK(destination);
   if (value >= 0)
     destination->reset(new int(value));
 }
 
+void SetDoubleScopedPtr(double value, scoped_ptr<double>* destination) {
+  DCHECK(destination);
+  if (value >= 0)
+    destination->reset(new double(value));
+}
+
+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) {
   DCHECK(source);
+  DCHECK(metadata.get());
   media::AudioVideoMetadataExtractor extractor;
 
   if (!extractor.Extract(source))
     return metadata.Pass();
 
   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()));
@@ skipping 14 matching lines @@
 
   for (std::map<std::string, std::string>::const_iterator it =
            extractor.raw_tags().begin();
        it != extractor.raw_tags().end(); ++it) {
     metadata->raw_tags.additional_properties.SetString(it->first, it->second);
   }
 
   return metadata.Pass();
 }
 
+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());
+    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());
+}
+
 }  // namespace
 
 MediaMetadataParser::MediaMetadataParser(media::DataSource* source,
                                          const std::string& mime_type)
     : source_(source),
       mime_type_(mime_type) {
 }
 
 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)) {
     media_thread_.reset(new base::Thread("media_thread"));
     CHECK(media_thread_->Start());
     base::PostTaskAndReplyWithResult(
         media_thread_->message_loop_proxy(),
         FROM_HERE,
         base::Bind(&ParseAudioVideoMetadata, source_, base::Passed(&metadata)),
         callback);
     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());
 }
 
 }  // namespace metadata