Convert utility process ParseMediaMetadata blob reading IPC to mojo

chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc

Index: chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc
diff --git a/chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc b/chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc
index 6c68b7d6fbeb26a46254099093de20d4f5c4c7fa..223e2a243ab2b6967b24482b591154a676f469c0 100644
--- a/chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc
+++ b/chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc
@@ -7,21 +7,39 @@
 #include <utility>
 
 #include "base/memory/ptr_util.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/blob_reader.h"
-#include "chrome/common/extensions/chrome_utility_extensions_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/child_process_data.h"
-#include "content/public/browser/utility_process_host.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using content::BrowserThread;
-
 namespace metadata {
 
+class SafeMediaMetadataParser::MediaDataSourceImpl
+    : public extensions::mojom::MediaDataSource {
+ public:
+  MediaDataSourceImpl(SafeMediaMetadataParser* owner,
+                      extensions::mojom::MediaDataSourcePtr* interface)
+      : binding_(this, interface), safe_media_metadata_parser_(owner) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  }
+
+  ~MediaDataSourceImpl() override = default;
+
+ private:
+  void ReadBlob(int64_t position,
+                int64_t length,
+                const ReadBlobCallback& callback) override {
+    safe_media_metadata_parser_->StartBlobRequest(callback, position, length);
+  }
+
+  mojo::Binding<extensions::mojom::MediaDataSource> binding_;
+  // |safe_media_metadata_parser_| owns |this|.
+  SafeMediaMetadataParser* const safe_media_metadata_parser_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaDataSourceImpl);
+};
+
 SafeMediaMetadataParser::SafeMediaMetadataParser(Profile* profile,
                                                  const std::string& blob_uuid,
                                                  int64_t blob_size,
@@ -31,143 +49,128 @@ SafeMediaMetadataParser::SafeMediaMetadataParser(Profile* profile,
       blob_uuid_(blob_uuid),
       blob_size_(blob_size),
       mime_type_(mime_type),
-      get_attached_images_(get_attached_images),
-      parser_state_(INITIAL_STATE) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+      get_attached_images_(get_attached_images) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void SafeMediaMetadataParser::Start(const DoneCallback& callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SafeMediaMetadataParser::StartWorkOnIOThread, this,
-                 callback));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&SafeMediaMetadataParser::StartOnIOThread, this, callback));
 }
 
-SafeMediaMetadataParser::~SafeMediaMetadataParser() {
-}
+SafeMediaMetadataParser::~SafeMediaMetadataParser() = default;
 
-void SafeMediaMetadataParser::StartWorkOnIOThread(
-    const DoneCallback& callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(INITIAL_STATE, parser_state_);
+void SafeMediaMetadataParser::StartOnIOThread(const DoneCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(!utility_process_mojo_client_);
   DCHECK(!callback.is_null());
 
   callback_ = callback;
 
-  utility_process_host_ = content::UtilityProcessHost::Create(
-      this, base::ThreadTaskRunnerHandle::Get())->AsWeakPtr();
-  utility_process_host_->SetName(l10n_util::GetStringUTF16(
-      IDS_UTILITY_PROCESS_MEDIA_FILE_CHECKER_NAME));
-  utility_process_host_->Start();
+  const base::string16 utility_process_name =
+      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_MEDIA_FILE_CHECKER_NAME);
 
-  parser_state_ = STARTED_PARSING_STATE;
+  utility_process_mojo_client_.reset(
+      new content::UtilityProcessMojoClient<extensions::mojom::MediaParser>(
+          utility_process_name));
+  utility_process_mojo_client_->set_error_callback(
+      base::Bind(&SafeMediaMetadataParser::ParseMediaMetadataFailed, this));
 
-  utility_process_host_->GetRemoteInterfaces()->GetInterface(&interface_);
+  utility_process_mojo_client_->Start();  // Start the utility process.
 
-  interface_.set_connection_error_handler(
-      base::Bind(&SafeMediaMetadataParser::ParseMediaMetadataFailed, this));
+  extensions::mojom::MediaDataSourcePtr source;
+  media_data_source_ = base::MakeUnique<MediaDataSourceImpl>(this, &source);
 
-  interface_->ParseMediaMetadata(
-      mime_type_, blob_size_, get_attached_images_,
+  utility_process_mojo_client_->service()->ParseMediaMetadata(
+      mime_type_, blob_size_, get_attached_images_, std::move(source),
       base::Bind(&SafeMediaMetadataParser::ParseMediaMetadataDone, this));
 }
 
 void SafeMediaMetadataParser::ParseMediaMetadataFailed() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(parser_state_, STARTED_PARSING_STATE);
-  DCHECK(!callback_.is_null());
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  interface_.reset();
+  utility_process_mojo_client_.reset();  // Terminate the utility process.
+  media_data_source_.reset();
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(callback_, false,
-                 base::Passed(std::unique_ptr<base::DictionaryValue>()),
-                 base::Passed(std::unique_ptr<std::vector<AttachedImage>>())));
+  std::unique_ptr<base::DictionaryValue> metadata_dictionary =
+      base::MakeUnique<base::DictionaryValue>();
+  std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images =
+      base::MakeUnique<std::vector<metadata::AttachedImage>>();
 
-  parser_state_ = FINISHED_PARSING_STATE;
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(callback_, false, base::Passed(&metadata_dictionary),
+                 base::Passed(&attached_images)));
 }
 
 void SafeMediaMetadataParser::ParseMediaMetadataDone(
     bool parse_success,
     std::unique_ptr<base::DictionaryValue> metadata_dictionary,
     const std::vector<AttachedImage>& attached_images) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(parser_state_, STARTED_PARSING_STATE);
-  DCHECK(!callback_.is_null());
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  interface_.reset();
+  utility_process_mojo_client_.reset();  // Terminate the utility process.
+  media_data_source_.reset();
 
   // We need to make a scoped copy of this vector since it will be destroyed
   // at the end of the handler.
   std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images_copy =
       base::MakeUnique<std::vector<metadata::AttachedImage>>(attached_images);
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
       base::Bind(callback_, parse_success, base::Passed(&metadata_dictionary),
                  base::Passed(&attached_images_copy)));
-
-  parser_state_ = FINISHED_PARSING_STATE;
 }
 
-void SafeMediaMetadataParser::OnUtilityProcessRequestBlobBytes(
-    int64_t request_id,
-    int64_t byte_start,
+void SafeMediaMetadataParser::StartBlobRequest(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    int64_t position,
     int64_t length) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
       base::Bind(&SafeMediaMetadataParser::StartBlobReaderOnUIThread, this,
-                 request_id, byte_start, length));
+                 callback, position, length));
 }
 
-void SafeMediaMetadataParser::StartBlobReaderOnUIThread(int64_t request_id,
-                                                        int64_t byte_start,
-                                                        int64_t length) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+void SafeMediaMetadataParser::StartBlobReaderOnUIThread(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    int64_t position,
+    int64_t length) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  // BlobReader is self-deleting.
-  BlobReader* reader = new BlobReader(profile_, blob_uuid_, base::Bind(
-      &SafeMediaMetadataParser::OnBlobReaderDoneOnUIThread, this, request_id));
-  reader->SetByteRange(byte_start, length);
+  BlobReader* reader = new BlobReader(  // BlobReader is self-deleting.
+      profile_, blob_uuid_,
+      base::Bind(&SafeMediaMetadataParser::BlobReaderDoneOnUIThread, this,
+                 callback));
+  reader->SetByteRange(position, length);
   reader->Start();
 }
 
-void SafeMediaMetadataParser::OnBlobReaderDoneOnUIThread(
-    int64_t request_id,
+void SafeMediaMetadataParser::BlobReaderDoneOnUIThread(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     std::unique_ptr<std::string> data,
     int64_t /* blob_total_size */) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeMediaMetadataParser::FinishRequestBlobBytes, this,
-                 request_id, base::Passed(std::move(data))));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&SafeMediaMetadataParser::FinishBlobRequest, this, callback,
+                 base::Passed(std::move(data))));
 }
 
-void SafeMediaMetadataParser::FinishRequestBlobBytes(
-    int64_t request_id,
+void SafeMediaMetadataParser::FinishBlobRequest(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     std::unique_ptr<std::string> data) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!utility_process_host_.get())
-    return;
-  utility_process_host_->Send(new ChromeUtilityMsg_RequestBlobBytes_Finished(
-      request_id, *data));
-}
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-bool SafeMediaMetadataParser::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(SafeMediaMetadataParser, message)
-    IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_RequestBlobBytes,
-        OnUtilityProcessRequestBlobBytes)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
+  if (utility_process_mojo_client_)
+    callback.Run(std::vector<uint8_t>(data->begin(), data->end()));
 }
 
 }  // namespace metadata