Convert utility process ParseMediaMetadata blob reading IPC to mojo

chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc

 // Copyright 2014 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/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
 
 #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(BrowserThread::IO);
+  }
+
+  ~MediaDataSourceImpl() override = default;
+
+ private:
+  void ReadBlob(int64_t request_id,
+                int64_t position,
+                int64_t length,
+                const ReadBlobCallback& callback) override {
+    safe_media_metadata_parser_->ProcessBlobRequest(callback, request_id,
+                                                    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,
                                                  const std::string& mime_type,
                                                  bool get_attached_images)
     : profile_(profile),
       blob_uuid_(blob_uuid),
       blob_size_(blob_size),
       mime_type_(mime_type),
-      get_attached_images_(get_attached_images),
-      parser_state_(INITIAL_STATE) {
+      get_attached_images_(get_attached_images) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void SafeMediaMetadataParser::Start(const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeMediaMetadataParser::StartWorkOnIOThread, this,
                  callback));
 }
 
-SafeMediaMetadataParser::~SafeMediaMetadataParser() {
-}
+SafeMediaMetadataParser::~SafeMediaMetadataParser() = default;
 
 void SafeMediaMetadataParser::StartWorkOnIOThread(
     const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(INITIAL_STATE, parser_state_);
   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_host_->GetRemoteInterfaces()->GetInterface(&interface_);
-
-  interface_.set_connection_error_handler(
+  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));
 
-  interface_->ParseMediaMetadata(
-      mime_type_, blob_size_, get_attached_images_,
+  utility_process_mojo_client_->Start();  // Start the utility process.
+
+  extensions::mojom::MediaDataSourcePtr source;
+  media_data_source_ = base::MakeUnique<MediaDataSourceImpl>(this, &source);
+
+  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());
 
-  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>>())));
-
-  parser_state_ = FINISHED_PARSING_STATE;
 }
 
 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());
 
-  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,
       base::Bind(callback_, parse_success, base::Passed(&metadata_dictionary),
                  base::Passed(&attached_images_copy)));
-
-  parser_state_ = FINISHED_PARSING_STATE;
 }
 
-void SafeMediaMetadataParser::OnUtilityProcessRequestBlobBytes(
+void SafeMediaMetadataParser::ProcessBlobRequest(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     int64_t request_id,
-    int64_t byte_start,
+    int64_t position,
     int64_t length) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
+      BrowserThread::UI, FROM_HERE,
       base::Bind(&SafeMediaMetadataParser::StartBlobReaderOnUIThread, this,
-                 request_id, byte_start, length));
+                 callback, request_id, position, length));
 }
 
-void SafeMediaMetadataParser::StartBlobReaderOnUIThread(int64_t request_id,
-                                                        int64_t byte_start,
-                                                        int64_t length) {
+void SafeMediaMetadataParser::StartBlobReaderOnUIThread(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    int64_t request_id,
+    int64_t position,
+    int64_t length) {
   DCHECK_CURRENTLY_ON(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, request_id));
+  reader->SetByteRange(position, length);
   reader->Start();
 }
 
-void SafeMediaMetadataParser::OnBlobReaderDoneOnUIThread(
+void SafeMediaMetadataParser::BlobReaderDoneOnUIThread(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     int64_t request_id,
     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,
+      base::Bind(&SafeMediaMetadataParser::FinishBlobRequest, this, callback,
                  request_id, base::Passed(std::move(data))));
 }
 
-void SafeMediaMetadataParser::FinishRequestBlobBytes(
+void SafeMediaMetadataParser::FinishBlobRequest(
+    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     int64_t request_id,
     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));
-}
 
-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_) {
+    const std::vector<uint8_t> blob(data->begin(), data->end());
+    callback.Run(request_id, blob);
+  }
 }
 
 }  // namespace metadata