Media Galleries API: Audio/Video attached pictures support.

chrome/browser/extensions/api/media_galleries/media_galleries_api.cc

 // Copyright (c) 2012 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.
 
 // Implements the Chrome Extensions Media Galleries API.
 
 #include "chrome/browser/extensions/api/media_galleries/media_galleries_api.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "base/callback.h"
+#include "base/guid.h"
 #include "base/lazy_instance.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/blob_reader.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_dialog_controller.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
 #include "chrome/browser/media_galleries/media_galleries_scan_result_dialog_controller.h"
 #include "chrome/browser/media_galleries/media_scan_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/extensions/api/media_galleries.h"
 #include "chrome/common/pref_names.h"
 #include "components/storage_monitor/storage_info.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/fileapi/blob_storage_host.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/media_galleries_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "grit/generated_resources.h"
 #include "net/base/mime_sniffer.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "webkit/common/blob/blob_data.h"
 
 using content::WebContents;
 using storage_monitor::MediaStorageUtil;
 using storage_monitor::StorageInfo;
 using web_modal::WebContentsModalDialogManager;
 
 namespace extensions {
 
 namespace MediaGalleries = api::media_galleries;
 namespace DropPermissionForMediaFileSystem =
@@ skipping 11 matching lines @@
 const char kNonExistentGalleryId[] = "Non-existent gallery id.";
 const char kNoScanPermission[] = "No permission to scan.";
 
 const char kDeviceIdKey[] = "deviceId";
 const char kGalleryIdKey[] = "galleryId";
 const char kIsAvailableKey[] = "isAvailable";
 const char kIsMediaDeviceKey[] = "isMediaDevice";
 const char kIsRemovableKey[] = "isRemovable";
 const char kNameKey[] = "name";
 
+const char kMetadataKey[] = "metadata";
+const char kAttachedImagesKey[] = "attachedImages";
+const char kBlobUUIDKey[] = "blobUUID";
+const char kTypeKey[] = "type";
+const char kSizeKey[] = "size";
+
 MediaFileSystemRegistry* media_file_system_registry() {
   return g_browser_process->media_file_system_registry();
 }
 
 MediaScanManager* media_scan_manager() {
   return media_file_system_registry()->media_scan_manager();
 }
 
 // Checks whether the MediaGalleries API is currently accessible (it may be
 // disallowed even if an extension has the requisite permission). Then
@@ skipping 722 matching lines @@
   if (!args_->Get(1, &options_value))
     return false;
   scoped_ptr<MediaGalleries::MediaMetadataOptions> options =
       MediaGalleries::MediaMetadataOptions::FromValue(*options_value);
   if (!options)
     return false;
 
   bool mime_type_only = options->metadata_type ==
       MediaGalleries::GET_METADATA_TYPE_MIMETYPEONLY;
 
+  // Get attached images by default.
+  bool get_attached_images =
+      options->metadata_type == MediaGalleries::GET_METADATA_TYPE_ALL ||
+      options->metadata_type == MediaGalleries::GET_METADATA_TYPE_NONE;
+
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesGetMetadataFunction::OnPreferencesInit, this,
-      mime_type_only, blob_uuid));
+      mime_type_only, get_attached_images, blob_uuid));
 }
 
 void MediaGalleriesGetMetadataFunction::OnPreferencesInit(
-    bool mime_type_only, const std::string& blob_uuid) {
+    bool mime_type_only, bool get_attached_images,
+    const std::string& blob_uuid) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // BlobReader is self-deleting.
   BlobReader* reader = new BlobReader(
       GetProfile(),
       blob_uuid,
-      base::Bind(&MediaGalleriesGetMetadataFunction::SniffMimeType, this,
-                 mime_type_only, blob_uuid));
+      base::Bind(&MediaGalleriesGetMetadataFunction::GetMetadata, this,
+                 mime_type_only, get_attached_images, blob_uuid));
   reader->SetByteRange(0, net::kMaxBytesToSniff);
   reader->Start();
 }
 
-void MediaGalleriesGetMetadataFunction::SniffMimeType(
-    bool mime_type_only, const std::string& blob_uuid,
-    scoped_ptr<std::string> blob_header, int64 total_blob_length) {
+void MediaGalleriesGetMetadataFunction::GetMetadata(
+    bool mime_type_only, bool get_attached_images,
+    const std::string& blob_uuid, scoped_ptr<std::string> blob_header,
+    int64 total_blob_length) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::string mime_type;
   bool mime_type_sniffed = net::SniffMimeTypeFromLocalData(
       blob_header->c_str(), blob_header->size(), &mime_type);
 
   if (!mime_type_sniffed) {
     SendResponse(false);
     return;
   }
 
   if (mime_type_only) {
     MediaGalleries::MediaMetadata metadata;
     metadata.mime_type = mime_type;
-    SetResult(metadata.ToValue().release());
+
+    base::DictionaryValue* result_dictionary = new base::DictionaryValue;
+    result_dictionary->Set(kMetadataKey, metadata.ToValue().release());
+    SetResult(result_dictionary);
     SendResponse(true);
     return;
   }
 
   scoped_refptr<metadata::SafeMediaMetadataParser> parser(
       new metadata::SafeMediaMetadataParser(GetProfile(), blob_uuid,
-                                            total_blob_length, mime_type));
+                                            total_blob_length, mime_type,
+                                            get_attached_images));
   parser->Start(base::Bind(
       &MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone, this));
 }
 
 void MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone(
-    bool parse_success, base::DictionaryValue* metadata_dictionary) {
+    bool parse_success, base::DictionaryValue* metadata_dictionary,
+    const std::vector<metadata::AttachedImage>& attached_images) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
   if (!parse_success) {
     SendResponse(false);
     return;
   }
 
-  SetResult(metadata_dictionary->DeepCopy());
+  if (attached_images.empty()) {
+    base::DictionaryValue* result_dictionary = new base::DictionaryValue;
+    result_dictionary->Set(kMetadataKey, metadata_dictionary->DeepCopy());
+    SetResult(result_dictionary);
+    SendResponse(true);
+    return;
+  }
+
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&MediaGalleriesGetMetadataFunction::CreateBlobsOnIOThread,
+                 this, attached_images),
+      base::Bind(&MediaGalleriesGetMetadataFunction::FinishWithBlobsOnUIThread,
+                 this, base::Owned(metadata_dictionary->DeepCopy()),
+                 attached_images));
+}
+
+std::vector<std::string>
+MediaGalleriesGetMetadataFunction::CreateBlobsOnIOThread(
+    const std::vector<metadata::AttachedImage>& attached_images) {
+  content::BlobStorageHost* blob_storage =
+      render_view_host()->GetProcess()->GetBlobStorageHost();

[jam, 2014/05/02 18:31:59]

RenderViewHost and RenderProcessHost are not thread safe, they can only be used
on the UI thread

[tommycli, 2014/05/07 21:39:05]

Done.

+  std::vector<std::string> blob_uuids;
+
+  for (std::vector<metadata::AttachedImage>::const_iterator it =
+           attached_images.begin();
+       it != attached_images.end(); ++it) {
+    // Here we notably use a UUID generated in the browser process instead of
+    // in WebKit. It is upper case and doesn't conform to UUID 4 specifications,
+    // but this doesn't seem to cause any harm.
+    std::string uuid = base::GenerateGUID();
+    BlobData::Item item;
+    item.SetToBytes(it->data.c_str(), it->data.size());
+
+    // These should never return false.
+    CHECK(blob_storage->StartBuildingBlob(uuid));
+    CHECK(blob_storage->AppendBlobDataItem(uuid, item));
+    CHECK(blob_storage->FinishBuildingBlob(uuid, it->type));

[jam, 2014/05/02 18:31:59]

since you only need these three methods, can you combine them into one and not
expose BlobStorageHost at all. it's best to keep that as an internal
implementation detail. you can have one method like CreateBlob(uuid, item,
type).

[tommycli, 2014/05/07 21:39:05]

Done.

+
+    blob_uuids.push_back(uuid);
+  }
+
+  return blob_uuids;
+}
+
+void MediaGalleriesGetMetadataFunction::FinishWithBlobsOnUIThread(
+    base::DictionaryValue* metadata_dictionary,
+    const std::vector<metadata::AttachedImage>& attached_images,
+    const std::vector<std::string>& blob_uuids) {
+  DCHECK(attached_images.size() == blob_uuids.size());
+
+  base::DictionaryValue* result_dictionary = new base::DictionaryValue;
+  result_dictionary->Set(kMetadataKey, metadata_dictionary->DeepCopy());
+
+  // The custom JS binding will reconstitute the blobs in the renderer.
+  base::ListValue* attached_images_list = new base::ListValue;
+  for (size_t i = 0; i < attached_images.size(); ++i) {
+    base::DictionaryValue* attached_image = new base::DictionaryValue;
+    attached_image->Set(kBlobUUIDKey, new base::StringValue(blob_uuids[i]));
+    attached_image->Set(kTypeKey, new base::StringValue(
+        attached_images[i].type));
+    attached_image->Set(kSizeKey, new base::FundamentalValue(
+        base::checked_cast<int>(attached_images[i].data.size())));
+    attached_images_list->Append(attached_image);
+  }
+  result_dictionary->Set(kAttachedImagesKey, attached_images_list);
+
+  SetResult(result_dictionary);
   SendResponse(true);
 }
 
 }  // namespace extensions