Convert utility process ParseMediaMetadata IPC to mojo

chrome/utility/extensions/extensions_handler.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/utility/extensions/extensions_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/chrome_extensions_client.h"
 #include "chrome/common/extensions/chrome_utility_extensions_messages.h"
+#include "chrome/common/extensions/media_parser.mojom.h"
 #include "chrome/common/media_galleries/metadata_types.h"
 #include "chrome/utility/chrome_content_utility_client.h"
 #include "chrome/utility/media_galleries/ipc_data_source.h"
 #include "chrome/utility/media_galleries/media_metadata_parser.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/utility/utility_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_utility_messages.h"
 #include "extensions/utility/unpacker.h"
 #include "media/base/media.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #include "ui/base/ui_base_switches.h"
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
 #include "media/base/media_file_checker.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/utility/media_galleries/itunes_pref_parser_win.h"
 #include "components/wifi/wifi_service.h"
 #endif  // defined(OS_WIN)
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #include "chrome/utility/media_galleries/iapps_xml_utils.h"
 #include "chrome/utility/media_galleries/itunes_library_parser.h"
 #include "chrome/utility/media_galleries/picasa_album_table_reader.h"
 #include "chrome/utility/media_galleries/picasa_albums_indexer.h"
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
-namespace extensions {
-
 namespace {
 
 bool Send(IPC::Message* message) {
   return content::UtilityThread::Get()->Send(message);
 }
 
 void ReleaseProcessIfNeeded() {
   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
 }
 
-void FinishParseMediaMetadata(
-    metadata::MediaMetadataParser* /* parser */,
-    const extensions::api::media_galleries::MediaMetadata& metadata,
-    const std::vector<metadata::AttachedImage>& attached_images) {
-  Send(new ChromeUtilityHostMsg_ParseMediaMetadata_Finished(
-      true, *metadata.ToValue(), attached_images));
-  ReleaseProcessIfNeeded();
-}
+class MediaParserImpl : public extensions::mojom::MediaParser {
+ public:
+  static void Create(ChromeContentUtilityClient* client,
+                     extensions::mojom::MediaParserRequest request) {
+    mojo::MakeStrongBinding(base::MakeUnique<MediaParserImpl>(client),

[tibell, 2017/01/09 03:55:52]

Do we know |client| will outlive this impl? We only delete this object when the
connection is closed, which could be very late. Should |client| be ref-counted?

[Noel Gordon, 2017/01/09 14:54:19]

Yes |client| outlives the impl (I retained the same semantics about |client|
lieftime that were used before this change).  The |client| lifetime is
controlled by the mojo callback and it calls ReleaseProcessIfNecessary() (see
line 91 below) which kills |client|.
Nope (see above).  Good questions about the lifetime issue btw, so thx for that.

Aside: if in future we changed the caller to use mojo's utility host client,
then lifetime of |client| for this mojo-ed API would probably become an issue.

+                            std::move(request));
+  }
+
+  explicit MediaParserImpl(ChromeContentUtilityClient* client)
+      : utility_client_(client) {}
+
+  ~MediaParserImpl() override = default;
+
+ private:
+  // extensions::mojom::MediaParser:
+  void ParseMediaMetadata(const std::string& mime_type,
+                          int64_t total_size,
+                          bool get_attached_images,
+                          const ParseMediaMetadataCallback& callback) override {
+    // Only one IPCDataSource may be created and added to the list of handlers.
+    std::unique_ptr<metadata::IPCDataSource> source(
+        new metadata::IPCDataSource(total_size));
+    metadata::MediaMetadataParser* parser = new metadata::MediaMetadataParser(
+        source.get(), mime_type, get_attached_images);
+    utility_client_->AddHandler(std::move(source));
+    parser->Start(base::Bind(&MediaParserImpl::ParseMediaMetadataDone,
+                             callback, base::Owned(parser)));
+  }
+
+  static void ParseMediaMetadataDone(
+      const ParseMediaMetadataCallback& callback,
+      metadata::MediaMetadataParser* /* parser */,
+      const extensions::api::media_galleries::MediaMetadata& metadata,
+      const std::vector<metadata::AttachedImage>& attached_images) {
+    callback.Run(true, metadata.ToValue(), attached_images);
+    ReleaseProcessIfNeeded();
+  }
+
+  ChromeContentUtilityClient* utility_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaParserImpl);
+};
 
 }  // namespace
 
-ExtensionsHandler::ExtensionsHandler(ChromeContentUtilityClient* utility_client)
-    : utility_client_(utility_client) {
+namespace extensions {
+
+ExtensionsHandler::ExtensionsHandler() {
   ExtensionsClient::Set(ChromeExtensionsClient::GetInstance());
 }
 
 ExtensionsHandler::~ExtensionsHandler() {
 }
 
 // static
 void ExtensionsHandler::PreSandboxStartup() {
   // Initialize media libraries for media file validation.
   media::InitializeMediaLibrary();
 }
 
+// static
+void ExtensionsHandler::ExposeInterfacesToBrowser(
+    service_manager::InterfaceRegistry* registry,
+    ChromeContentUtilityClient* client,
+    bool running_elevated) {
+  // If our process runs with elevated privileges, only add elevated
+  // Mojo services to the service_manager::InterfaceRegistry.
+  if (running_elevated)
+    return;
+
+  registry->AddInterface(base::Bind(&MediaParserImpl::Create, client));
+}
+
 bool ExtensionsHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionsHandler, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_CheckMediaFile, OnCheckMediaFile)
-    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseMediaMetadata,
-                        OnParseMediaMetadata)
 
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesPrefXml,
                         OnParseITunesPrefXml)
 #endif  // defined(OS_WIN)
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesLibraryXmlFile,
                         OnParseITunesLibraryXmlFile)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParsePicasaPMPDatabase,
                         OnParsePicasaPMPDatabase)
     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_IndexPicasaAlbumsContents,
                         OnIndexPicasaAlbumsContents)
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_GetWiFiCredentials,
                         OnGetWiFiCredentials)
 #endif  // defined(OS_WIN)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
+
   return handled || utility_handler_.OnMessageReceived(message);
 }
 
 void ExtensionsHandler::OnCheckMediaFile(
     int64_t milliseconds_of_decoding,
     const IPC::PlatformFileForTransit& media_file) {
 #if !defined(MEDIA_DISABLE_FFMPEG)
   media::MediaFileChecker checker(
       IPC::PlatformFileForTransitToFile(media_file));
   const bool check_success = checker.Start(
       base::TimeDelta::FromMilliseconds(milliseconds_of_decoding));
   Send(new ChromeUtilityHostMsg_CheckMediaFile_Finished(check_success));
 #else
   Send(new ChromeUtilityHostMsg_CheckMediaFile_Finished(false));
 #endif
   ReleaseProcessIfNeeded();
 }
 
-void ExtensionsHandler::OnParseMediaMetadata(const std::string& mime_type,
-                                             int64_t total_size,
-                                             bool get_attached_images) {
-  // Only one IPCDataSource may be created and added to the list of handlers.
-  std::unique_ptr<metadata::IPCDataSource> source(
-      new metadata::IPCDataSource(total_size));
-  metadata::MediaMetadataParser* parser = new metadata::MediaMetadataParser(
-      source.get(), mime_type, get_attached_images);
-  utility_client_->AddHandler(std::move(source));
-  parser->Start(base::Bind(&FinishParseMediaMetadata, base::Owned(parser)));
-}
-
 #if defined(OS_WIN)
 void ExtensionsHandler::OnParseITunesPrefXml(
     const std::string& itunes_xml_data) {
   base::FilePath library_path(
       itunes::FindLibraryLocationInPrefXml(itunes_xml_data));
   Send(new ChromeUtilityHostMsg_GotITunesDirectory(library_path));
   ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_WIN)
 
@@ skipping 51 matching lines @@
 
   std::string key_data;
   std::string error;
   wifi_service->GetKeyFromSystem(network_guid, &key_data, &error);
 
   Send(new ChromeUtilityHostMsg_GotWiFiCredentials(key_data, error.empty()));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace extensions