Add shared library support

Implement platform support for loading shared library in decoder.

This feature will be disabled by default and only compiled when flag
enable_cros_ime_decoder in chromeos/services/ime/public/features.gni
is turned on.


Bug: 837156
Change-Id: Iaec701361f50061ded08a1998975a521701b0387
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1659553Reviewed-by: Marti Wong <martiw@chromium.org>
Reviewed-by: Shu Chen <shuchen@chromium.org>
Commit-Queue: Leo Zhang <googleo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#669926}

chromeos/services/ime/decoder/decoder_engine.cc

@@ -4,6 +4,7 @@
 
 #include "chromeos/services/ime/decoder/decoder_engine.h"
 
+#include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "build/buildflag.h"
 #include "chromeos/services/ime/public/cpp/buildflags.h"
@@ -13,17 +14,52 @@ namespace ime {
 
 namespace {
 
+// TODO(https://crbug.com/837156): Use define instead.
 #if BUILDFLAG(ENABLE_CROS_IME_EXAMPLE_SO)
 const char kDecoderLibName[] = "input_decoder_example";
 #else
 const char kDecoderLibName[] = "input_decoder_engine";
 #endif
 
+// A client delegate that makes calls on client side.
+class ClientDelegate : public ImeClientDelegate {
+ public:
+  ClientDelegate(const std::string& ime_spec,
+                 mojo::PendingRemote<mojom::InputChannel> remote)
+      : ime_spec_(ime_spec), client_remote_(std::move(remote)) {
+    client_remote_.set_disconnect_handler(base::BindOnce(
+        &ClientDelegate::OnDisconnected, base::Unretained(this)));
+  }
+
+  ~ClientDelegate() override {}
+
+  const char* ImeSpec() override { return ime_spec_.c_str(); }
+
+  void Process(const uint8_t* data, size_t size) override {
+    if (client_remote_ && client_remote_.is_bound()) {
+      std::vector<uint8_t> msg(data, data + size);
+      client_remote_->ProcessMessage(msg, base::DoNothing());
+    }
+  }
+
+  void Destroy() override {}
+
+ private:
+  void OnDisconnected() {
+    client_remote_.reset();
+    LOG(ERROR) << "Client remote is disconnected." << ime_spec_;
+  }
+
+  // The ime specification which is unique in the scope of engine.
+  std::string ime_spec_;
+
+  // The InputChannel remote used to talk to the client.
+  mojo::Remote<mojom::InputChannel> client_remote_;
+};
+
 }  // namespace
 
-DecoderEngine::DecoderEngine(
-    service_manager::Connector* connector,
-    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+DecoderEngine::DecoderEngine(ImeCrosPlatform* platform) : platform_(platform) {
   // TODO(https://crbug.com/837156): Connect utility services for InputEngine
   // via connector(). Eg. take advantage of the file and network services to
   // download relevant language models required by the decocers to the device.
@@ -31,39 +67,52 @@ DecoderEngine::DecoderEngine(
   // Load the decoder library.
   base::NativeLibraryLoadError load_error;
   base::FilePath lib_path(base::GetNativeLibraryName(kDecoderLibName));
-  library_.Reset(base::LoadNativeLibrary(lib_path, &load_error));
+  library_ = base::ScopedNativeLibrary(lib_path);
 
   if (!library_.is_valid()) {
-    LOG(ERROR) << "Failed to load a decoder shared library.";
+    LOG(ERROR) << "Failed to load a decoder shared library, error: "
+               << library_.GetError()->ToString();
     return;
   }
 
-  // TODO(https://crbug.com/837156): Based on the defined function pointer types
-  // in DecoderAPILibrary, load all required function pointers.
+  ImeMainEntryCreateFn createMainEntryFn =
+      reinterpret_cast<ImeMainEntryCreateFn>(
+          library_.GetFunctionPointer(IME_MAIN_ENTRY_CREATE_FN_NAME));
+
+  engine_main_entry_ = createMainEntryFn(platform_);
+  LOG(ERROR) << "Loaded SO main_entry in DecoderEngine!";
 }
 
 DecoderEngine::~DecoderEngine() {}
 
-bool DecoderEngine::BindRequest(const std::string& ime_spec,
-                                mojom::InputChannelRequest request,
-                                mojom::InputChannelPtr client,
-                                const std::vector<uint8_t>& extra) {
-  if (!IsImeSupported(ime_spec))
+bool DecoderEngine::BindRequest(
+    const std::string& ime_spec,
+    mojo::PendingReceiver<mojom::InputChannel> receiver,
+    mojo::PendingRemote<mojom::InputChannel> remote,
+    const std::vector<uint8_t>& extra) {
+  // If the shared library supports this ime_spec.
+  if (IsImeSupported(ime_spec)) {
+    // Activates an IME engine via the shared library. Passing a
+    // |ClientDelegate| for engine instance created by the shared library to
+    // make safe calls on the client.
+    if (engine_main_entry_->ActivateIme(
+            ime_spec.c_str(),
+            new ClientDelegate(ime_spec, std::move(remote)))) {
+      channel_receivers_.Add(this, std::move(receiver));
+      // TODO(https://crbug.com/837156): Registry connection error handler.
+      return true;
+    }
     return false;
-  // TODO(https://crbug.com/837156): Notify the input logic loaded from the
-  // shared library about the change by forwarding the information received.
-  // Moreover, in order to make safe calls on the clientPtr inside the input
-  // logic with multiple threads, we will send a wrapper of the clientPtr,
-  // where we make sure it runs in the correct SequencedTaskRunner.
-  channel_bindings_.AddBinding(this, std::move(request));
-  // TODO(https://crbug.com/837156): Registry connection error handler.
-  return true;
+  }
+
+  // Otherwise, try the rule-based engine for this ime_spec.
+  return InputEngine::BindRequest(ime_spec, std::move(receiver),
+                                  std::move(remote), extra);
 }
 
 bool DecoderEngine::IsImeSupported(const std::string& ime_spec) {
-  // TODO(https://crbug.com/837156): Check the capability of the loaded shared
-  // library first.
-  return InputEngine::IsImeSupported(ime_spec);
+  return engine_main_entry_ &&
+         engine_main_entry_->IsImeSupported(ime_spec.c_str());
 }
 
 void DecoderEngine::ProcessMessage(const std::vector<uint8_t>& message,

chromeos/services/ime/decoder/decoder_engine.h

@@ -7,6 +7,7 @@
 
 #include "base/scoped_native_library.h"
 #include "chromeos/services/ime/input_engine.h"
+#include "chromeos/services/ime/public/cpp/shared_lib/interfaces.h"
 #include "chromeos/services/ime/public/mojom/input_engine.mojom.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -23,15 +24,16 @@ namespace ime {
 // a premium typing experience.
 class DecoderEngine : public InputEngine {
  public:
-  DecoderEngine(service_manager::Connector* connector,
-                scoped_refptr<base::SequencedTaskRunner> task_runner);
+  explicit DecoderEngine(ImeCrosPlatform* platform);
   ~DecoderEngine() override;
 
   // InputEngine overrides:
   bool BindRequest(const std::string& ime_spec,
-                   mojom::InputChannelRequest request,
-                   mojom::InputChannelPtr client,
+                   mojo::PendingReceiver<mojom::InputChannel> receiver,
+                   mojo::PendingRemote<mojom::InputChannel> remote,
                    const std::vector<uint8_t>& extra) override;
+
+  // Returns whether the loaded shared library supports this ime_spec.
   bool IsImeSupported(const std::string& ime_spec) override;
   void ProcessMessage(const std::vector<uint8_t>& message,
                       ProcessMessageCallback callback) override;
@@ -40,7 +42,11 @@ class DecoderEngine : public InputEngine {
   // Shared library handle of the implementation for input logic with decoders.
   base::ScopedNativeLibrary library_;
 
-  mojo::BindingSet<mojom::InputChannel> channel_bindings_;
+  ImeEngineMainEntry* engine_main_entry_ = nullptr;
+
+  ImeCrosPlatform* platform_ = nullptr;
+
+  mojo::ReceiverSet<mojom::InputChannel> channel_receivers_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderEngine);
 };

chromeos/services/ime/decoder/downloader_impl.cc

@@ -18,7 +18,7 @@ DownloaderImpl::~DownloaderImpl() {
 int DownloaderImpl::DownloadToFile(const char* url,
                                    const DownloadOptions& options,
                                    const char* file_path,
-                                   DownloadCallback callback) {
+                                   ImeCrosDownloadCallback callback) {
   // TODO(crbug/946913): Implement this.
   return 0;
 }

chromeos/services/ime/decoder/downloader_impl.h

@@ -11,7 +11,7 @@
 namespace chromeos {
 namespace ime {
 
-class DownloaderImpl : public Downloader {
+class DownloaderImpl : public ImeCrosDownloader {
  public:
   explicit DownloaderImpl();
   ~DownloaderImpl() override;
@@ -19,7 +19,7 @@ class DownloaderImpl : public Downloader {
   int DownloadToFile(const char* url,
                      const DownloadOptions& options,
                      const char* file_path,
-                     DownloadCallback callback) override;
+                     ImeCrosDownloadCallback callback) override;
 
   void Cancel(int request_id) override;
 

chromeos/services/ime/ime_service.cc

@@ -29,8 +29,7 @@ void ImeService::OnStart() {
       &ImeService::OnConnectionLost, base::Unretained(this)));
 
 #if BUILDFLAG(ENABLE_CROS_IME_DECODER)
-  input_engine_ = std::make_unique<DecoderEngine>(
-      service_binding_.GetConnector(), base::SequencedTaskRunnerHandle::Get());
+  input_engine_ = std::make_unique<DecoderEngine>(this);
 #else
   input_engine_ = std::make_unique<InputEngine>();
 #endif
@@ -68,5 +67,31 @@ void ImeService::OnConnectionLost() {
   }
 }
 
+const char* ImeService::GetImeBundleDir() {
+  return "";
+}
+
+const char* ImeService::GetImeGlobalDir() {
+  return "";
+}
+
+const char* ImeService::GetImeUserHomeDir() {
+  return "";
+}
+
+int ImeService::SimpleDownloadToFile(const char* url,
+                                     const char* file_path,
+                                     SimpleDownloadCallback callback) {
+  // TODO(https://crbug.com/837156): Create a download with PlatformAccess
+  // Mojo remote. Make sure the parent of |file_path| is ImeUserHomeDir.
+  return 0;
+}
+
+ImeCrosDownloader* ImeService::GetDownloader() {
+  // TODO(https://crbug.com/837156): Create a ImeCrosDownloader based on its
+  // specification in interfaces. The caller should free it after use.
+  return nullptr;
+}
+
 }  // namespace ime
 }  // namespace chromeos

chromeos/services/ime/ime_service.h

@@ -6,6 +6,7 @@
 #define CHROMEOS_SERVICES_IME_IME_SERVICE_H_
 
 #include "chromeos/services/ime/input_engine.h"
+#include "chromeos/services/ime/public/cpp/shared_lib/interfaces.h"
 #include "chromeos/services/ime/public/mojom/input_engine.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -19,7 +20,8 @@ namespace chromeos {
 namespace ime {
 
 class ImeService : public service_manager::Service,
-                   public mojom::InputEngineManager {
+                   public mojom::InputEngineManager,
+                   public ImeCrosPlatform {
  public:
   explicit ImeService(
       mojo::PendingReceiver<service_manager::mojom::Service> receiver);
@@ -40,6 +42,15 @@ class ImeService : public service_manager::Service,
       const std::vector<uint8_t>& extra,
       ConnectToImeEngineCallback callback) override;
 
+  // ImeCrosPlatform overrides:
+  const char* GetImeBundleDir() override;
+  const char* GetImeGlobalDir() override;
+  const char* GetImeUserHomeDir() override;
+  int SimpleDownloadToFile(const char* url,
+                           const char* file_path,
+                           SimpleDownloadCallback callback) override;
+  ImeCrosDownloader* GetDownloader() override;
+
   // Adds a mojom::InputEngineManager receiver to this object.
   void AddInputEngineManagerReceiver(
       mojo::PendingReceiver<mojom::InputEngineManager> receiver);

chromeos/services/ime/public/cpp/shared_lib/interfaces.h

@@ -63,7 +63,10 @@ namespace ime {
 // issued |request_id| (as returned by DownloadToFile()) and an |error_code| (as
 // defined at
 // https://cs.chromium.org/chromium/src/net/base/net_error_list.h?rcl=f9c935b73381772d508eebba1e216c437139d475).
-typedef void (*DownloadCallback)(int request_id, int status_code);
+typedef void (*ImeCrosDownloadCallback)(int request_id, int status_code);
+
+// A simple downloading callback.
+typedef void (*SimpleDownloadCallback)(int status_code, const char* file_path);
 
 // Based on RequestPriority defined at
 // https://cs.chromium.org/chromium/src/net/base/request_priority.h?rcl=f9c935b73381772d508eebba1e216c437139d475
@@ -97,9 +100,9 @@ struct DownloadOptions {
 };
 
 // Provides CrOS network download service to the shared library.
-class Downloader {
+class ImeCrosDownloader {
  protected:
-  virtual ~Downloader() = default;
+  virtual ~ImeCrosDownloader() = default;
 
  public:
   // Download data from the given |url| and store into a file located at the
@@ -114,7 +117,7 @@ class Downloader {
   virtual int DownloadToFile(const char* url,
                              const DownloadOptions& options,
                              const char* file_path,
-                             DownloadCallback callback) = 0;
+                             ImeCrosDownloadCallback callback) = 0;
 
   // Cancel the download whose |request_id| is given (|request_id| is issued
   // in the return value of each DownloadToFile() call). The callback of a
@@ -124,14 +127,14 @@ class Downloader {
   virtual void Cancel(int request_id) = 0;
 };
 
-// This defines the `Platform` interface, which is used throughout the shared
-// library to manage platform-specific data/operations.
+// This defines the `ImeCrosPlatform` interface, which is used throughout the
+// shared library to manage platform-specific data/operations.
 //
 // This class should be provided by the IME service before creating an
 // `ImeEngineMainEntry` and be always owned by the IME service.
-class Platform {
+class ImeCrosPlatform {
  protected:
-  virtual ~Platform() = default;
+  virtual ~ImeCrosPlatform() = default;
 
  public:
   // The three methods below are Getters of the local data directories on the
@@ -154,8 +157,15 @@ class Platform {
   // Get the Downloader that provides CrOS network download service. Ownership
   // of the returned Downloader instance is never transferred, i.e. it remains
   // owned by the IME service / Platform at all times.
-  virtual Downloader* GetDownloader() = 0;
-  
+  virtual ImeCrosDownloader* GetDownloader() = 0;
+
+  // A shortcut for starting a downloading by the network |SimpleURLLoader|.
+  // Each SimpleDownloadToFile can only be used for a single request.
+  // Make a call after the previous task completes or cancels.
+  virtual int SimpleDownloadToFile(const char* url,
+                                   const char* file_path,
+                                   SimpleDownloadCallback callback) = 0;
+
   // TODO(https://crbug.com/837156): Provide Logger for main entry.
 };
 
@@ -224,7 +234,7 @@ class ImeEngineMainEntry {
 // name defined in IME_MAIN_ENTRY_CREATE_FN_NAME.
 //
 // Returns an instance of ImeEngineMainEntry from the IME shared library.
-typedef ImeEngineMainEntry* (*ImeMainEntryCreateFn)(Platform*);
+typedef ImeEngineMainEntry* (*ImeMainEntryCreateFn)(ImeCrosPlatform*);
 
 // Defined name of ImeMainEntryCreateFn exported from shared library.
 #define IME_MAIN_ENTRY_CREATE_FN_NAME "CreateImeMainEntry"