[ios Mojo] iOS facade class for Mojo API.

ios/web/webui/mojo_facade.mm

+// Copyright 2016 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.
+
+#import "ios/web/webui/mojo_facade.h"
+
+#import <Foundation/Foundation.h>
+
+#include "base/ios/block_types.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/mac/scoped_block.h"
+#include "base/memory/singleton.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/values.h"
+#import "ios/web/public/web_state/js/crw_js_injection_evaluator.h"
+#include "ios/web/public/web_thread.h"
+#include "mojo/public/c/system/core.h"
+#include "services/shell/public/interfaces/interface_provider.mojom.h"
+
+namespace web {
+
+namespace {
+
+// Wraps Mojo integer into |base::Value| as |TYPE_INTEGER|.
+template <typename MojoIntegerT>
+std::unique_ptr<base::Value> ValueFromMojoInteger(MojoIntegerT handle) {
+  return std::unique_ptr<base::Value>(
+      new base::FundamentalValue(static_cast<int>(handle)));
+}
+
+// Singleton which holds contexts for all currently active watches. Must be used
+// only on UI thread.
+class WatchCallbackHolder {
+ public:
+  static WatchCallbackHolder* GetInstance() {
+    DCHECK_CURRENTLY_ON(WebThread::UI);
+    return base::Singleton<WatchCallbackHolder>::get();
+  }
+
+  // Adds |callback_block| which must be executed when the Watch callback fires.
+  // Returns context which can be passed to |Run| to execute the block. Callers
+  // are responsible for removing contexts which are no longer active by calling
+  // |Remove|.
+  uintptr_t Add(void (^callback_block)(void)) {
+    DCHECK_CURRENTLY_ON(WebThread::UI);
+    callbacks_[++last_watch_context_].reset([callback_block copy]);
+    return last_watch_context_;
+  }
+
+  // Executes the callback previously added by calling |Add|. |watch_context| is
+  // the context returned from |Add|. Calling this method for a context which
+  // has been previously removed is no-op.
+  void Run(uintptr_t watch_context) {
+    DCHECK_CURRENTLY_ON(WebThread::UI);
+    ProceduralBlock callback = callbacks_[watch_context];
+    if (callback)
+      callback();
+  }
+
+  // Removes previously added callback. |watch_context| is the context returned
+  // from |Add|.
+  void Remove(uintptr_t watch_context) {
+    DCHECK_CURRENTLY_ON(WebThread::UI);
+    DCHECK(callbacks_.find(watch_context) != callbacks_.end());
+    callbacks_.erase(watch_context);
+  }
+
+ private:
+  WatchCallbackHolder() : last_watch_context_(0) {}
+  ~WatchCallbackHolder() {
+    // Clients are responsible for removing all callbacks before shutdown.
+    DCHECK(callbacks_.empty());
+  }
+
+  // Required by base::Singleton.
+  friend struct base::DefaultSingletonTraits<WatchCallbackHolder>;
+
+  // Context for the last added callback. Context for the next callback will be
+  // |last_watch_context_ + 1|.
+  uintptr_t last_watch_context_;
+  // Callbacks added via |Add| method.
+  std::map<uintptr_t, base::mac::ScopedBlock<ProceduralBlock>> callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(WatchCallbackHolder);
+};
+
+// Callback for |MojoWatch| call. Called when:
+// - watched signal has been satisfied;
+// - it became known that none of the watched signals will ever be satisfied;
+// - handle was closed;
+void MojoWatchCallback(uintptr_t watch_context,
+                       MojoResult result,
+                       struct MojoHandleSignalsState signals_state,
+                       MojoWatchNotificationFlags flags) {
+  WatchCallbackHolder::GetInstance()->Run(watch_context);
+}
+
+}  // namespace
+
+MojoFacade::MojoFacade(shell::mojom::InterfaceProvider* interface_provider,
+                       id<CRWJSInjectionEvaluator> script_evaluator)
+    : interface_provider_(interface_provider),
+      script_evaluator_(script_evaluator) {
+  DCHECK_CURRENTLY_ON(WebThread::UI);
+  DCHECK(interface_provider_);
+  DCHECK(script_evaluator_);
+}
+
+MojoFacade::~MojoFacade() {
+  DCHECK_CURRENTLY_ON(WebThread::UI);
+  for (uintptr_t context : watch_contexts_)
+    WatchCallbackHolder::GetInstance()->Remove(context);
+}
+
+std::string MojoFacade::HandleMojoMessage(
+    const std::string& mojo_message_as_json) {
+  DCHECK_CURRENTLY_ON(WebThread::UI);
+  std::string name;
+  std::unique_ptr<base::DictionaryValue> args;
+  if (!GetMessageNameAndArguments(mojo_message_as_json, &name, &args)) {
+    return "";

[Eugene But (OOO till 7-30), 2016/05/07 00:07:52]

On iOS we fail gracefully if JS message is malformed because any page can send
these messages. WebUI pages should run only Chrome scripts, so maybe we should
crash instead of returning empty json?

[Ken Rockot(use gerrit already), 2016/05/09 15:44:38]

What do you mean by "any page can send these messages?" On the surface this
sounds like a very, very scary statement.

[Eugene But (OOO till 7-30), 2016/05/09 16:08:10]

A lot of stuff on iOS is implemented in JavaScript. Chrome injects scripts and
then scripts send messages to the native code. Any web page could send those
messages to the native code and there was no reliable way to protect. We tried
multiple approaches to ensure authenticity, but we were able to break all of
them. So messages received from a web page could be trusted. And no message
should be able to crash the app.

Mojo case is very different, because mojo messages can be sent only from
chrome:// pages and only Chrome code can run on those pages. WKWebView provides
reliable api to check the sender's origin so every message is trusted. 

[Eugene But (OOO till 7-30), 2016/05/10 02:00:56]

Replaced returns with CHECKs

+  }
+
+  std::unique_ptr<base::Value> result;
+  if (name == "service_provider.connectToService") {
+    result = HandleServiceProviderConnectToService(args.get());
+  } else if (name == "core.close") {
+    result = HandleCoreClose(args.get());
+  } else if (name == "core.createMessagePipe") {
+    result = HandleCoreCreateMessagePipe(args.get());
+  } else if (name == "core.writeMessage") {
+    result = HandleCoreWriteMessage(args.get());
+  } else if (name == "core.readMessage") {
+    result = HandleCoreReadMessage(args.get());
+  } else if (name == "support.watch") {
+    result = HandleSupportWatch(args.get());
+  }
+
+  if (!result) {
+    return "";
+  }
+
+  std::string json_result;
+  base::JSONWriter::Write(*result, &json_result);
+  return json_result;
+}
+
+bool MojoFacade::GetMessageNameAndArguments(
+    const std::string& mojo_message_as_json,
+    std::string* out_name,
+    std::unique_ptr<base::DictionaryValue>* out_args) {
+  int error_code = 0;
+  std::string error_message;
+  std::unique_ptr<base::Value> mojo_message_as_value(
+      base::JSONReader::ReadAndReturnError(mojo_message_as_json, false,
+                                           &error_code, &error_message));
+  if (error_code) {
+    DLOG(WARNING) << "JSON parse error: " << error_message;
+    return false;
+  }
+  base::DictionaryValue* mojo_message = nullptr;
+  if (!mojo_message_as_value->GetAsDictionary(&mojo_message)) {
+    DLOG(WARNING) << "mojo message is not a dictionary";
+    return false;
+  }
+
+  std::string name;
+  if (!mojo_message->GetString("name", &name)) {
+    DLOG(WARNING) << "missing 'name' key in mojo message";
+    return false;
+  }
+
+  base::DictionaryValue* args = nullptr;
+  if (!mojo_message->GetDictionary("args", &args)) {
+    DLOG(WARNING) << "missing 'args' key in mojo message";
+    return false;
+  }
+
+  *out_name = name;
+  *out_args = args->CreateDeepCopy();
+  return true;
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleServiceProviderConnectToService(
+    const base::DictionaryValue* args) {
+  const base::Value* service_name_as_value = nullptr;
+  if (!args->Get("serviceName", &service_name_as_value)) {
+    DLOG(WARNING) << "missing 'serviceName' key in mojo message";
+    return nullptr;
+  }
+
+  // By design service_provider.connectToService either succeeds or crashes, so
+  // check if service name is a valid string is intentionally omitted.
+  std::string service_name_as_string;
+  service_name_as_value->GetAsString(&service_name_as_string);
+
+  mojo::MessagePipe pipe;
+  interface_provider_->GetInterface(mojo::String::From(service_name_as_string),
+                                    std::move(pipe.handle0));
+
+  return ValueFromMojoInteger(pipe.handle1.release().value());
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleCoreClose(
+    const base::DictionaryValue* args) {
+  int handle = 0;
+  if (!args->GetInteger("handle", &handle)) {
+    DLOG(WARNING) << "missing 'handle' key in mojo message";
+    return nullptr;
+  }
+
+  return ValueFromMojoInteger(MojoClose(handle));
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleCoreCreateMessagePipe(
+    base::DictionaryValue* args) {
+  const base::Value* options_as_value = nullptr;
+  if (!args->Get("optionsDict", &options_as_value)) {
+    DLOG(WARNING) << "missing 'optionsDict' key in mojo message";
+    return nullptr;
+  }
+
+  std::unique_ptr<MojoCreateMessagePipeOptions> options;
+  if (options_as_value->IsType(base::Value::TYPE_DICTIONARY)) {
+    // Extract options and reset |options| pointer when this codepath is hit.
+    NOTIMPLEMENTED();
+  } else if (!options_as_value->IsType(base::Value::TYPE_NULL)) {
+    DLOG(WARNING) << "'optionsDict' is neither a dict nor null";
+    return nullptr;
+  }
+
+  MojoHandle handle0;
+  MojoHandle handle1;
+  MojoCreateMessagePipe(options.get(), &handle0, &handle1);
+
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+  result->SetInteger("handle0", handle0);
+  result->SetInteger("handle1", handle1);
+  return std::unique_ptr<base::Value>(result.release());
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleCoreWriteMessage(
+    base::DictionaryValue* args) {
+  int handle = 0;
+  if (!args->GetInteger("handle", &handle)) {
+    DLOG(WARNING) << "missing 'handle' key in mojo message";
+    return nullptr;
+  }
+
+  base::ListValue* handles_list = nullptr;
+  if (!args->GetList("handles", &handles_list)) {
+    DLOG(WARNING) << "missing 'handles' key in mojo message";
+    return nullptr;
+  }
+
+  base::DictionaryValue* buffer = nullptr;
+  if (!args->GetDictionary("buffer", &buffer)) {
+    DLOG(WARNING) << "missing 'buffer' key in mojo message";
+    return nullptr;
+  }
+
+  const base::Value* flags_as_value = nullptr;
+  if (!args->Get("flags", &flags_as_value)) {
+    DLOG(WARNING) << "missing 'flags' key in mojo message";
+    return nullptr;
+  }
+
+  int flags = MOJO_WRITE_MESSAGE_FLAG_NONE;
+  if (!flags_as_value->GetAsInteger(&flags)) {
+    flags = MOJO_WRITE_MESSAGE_FLAG_NONE;
+  }
+
+  std::vector<MojoHandle> handles(handles_list->GetSize());
+  for (size_t i = 0; i < handles_list->GetSize(); i++) {
+    int one_handle = 0;
+    handles_list->GetInteger(i, &one_handle);
+    handles[i] = one_handle;
+  }
+
+  std::vector<uint8_t> bytes(buffer->size());
+  for (size_t i = 0; i < buffer->size(); i++) {
+    int one_byte = 0;
+    buffer->GetInteger(base::IntToString(i), &one_byte);
+    bytes[i] = one_byte;
+  }
+
+  MojoResult result =
+      MojoWriteMessage(static_cast<MojoHandle>(handle), bytes.data(),
+                       bytes.size(), handles.data(), handles.size(), flags);
+
+  return ValueFromMojoInteger(result);
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleCoreReadMessage(
+    const base::DictionaryValue* args) {
+  const base::Value* handle_as_value = nullptr;
+  if (!args->Get("handle", &handle_as_value)) {
+    DLOG(WARNING) << "missing 'handle' key in mojo message";
+    return nullptr;
+  }
+  int handle_as_int = 0;
+  if (!handle_as_value->GetAsInteger(&handle_as_int)) {
+    handle_as_int = 0;
+  }
+
+  const base::Value* flags_as_value = nullptr;
+  if (!args->Get("flags", &flags_as_value)) {
+    DLOG(WARNING) << "missing 'flags' key in mojo message";
+    return nullptr;
+  }
+
+  int flags = MOJO_READ_MESSAGE_FLAG_NONE;
+  if (!flags_as_value->GetAsInteger(&flags)) {
+    flags = MOJO_READ_MESSAGE_FLAG_NONE;
+  }
+
+  uint32_t num_bytes = 0;
+  uint32_t num_handles = 0;
+  MojoResult mojo_result =
+      MojoReadMessage(static_cast<MojoHandle>(handle_as_int), nullptr,
+                      &num_bytes, nullptr, &num_handles, flags);
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+
+  if (mojo_result == MOJO_RESULT_RESOURCE_EXHAUSTED) {
+    std::vector<uint8_t> bytes(num_bytes);
+    std::vector<MojoHandle> handles(num_handles);
+    mojo_result =
+        MojoReadMessage(static_cast<MojoHandle>(handle_as_int), bytes.data(),
+                        &num_bytes, handles.data(), &num_handles, flags);
+
+    base::ListValue* handles_list = new base::ListValue;
+    for (uint32_t i = 0; i < num_handles; i++) {
+      handles_list->AppendInteger(handles[i]);
+    }
+    result->Set("handles", std::unique_ptr<base::Value>(handles_list));
+
+    base::ListValue* buffer = new base::ListValue;
+    for (uint32_t i = 0; i < num_bytes; i++) {
+      buffer->AppendInteger(bytes[i]);
+    }
+    result->Set("buffer", std::unique_ptr<base::Value>(buffer));
+  }
+  result->SetInteger("result", mojo_result);
+
+  return std::unique_ptr<base::Value>(result.release());
+}
+
+std::unique_ptr<base::Value> MojoFacade::HandleSupportWatch(
+    const base::DictionaryValue* args) {
+  int handle = 0;
+  if (!args->GetInteger("handle", &handle)) {
+    DLOG(WARNING) << "missing 'handle' key in mojo message";
+    return nullptr;
+  }
+  int signals = 0;
+  if (!args->GetInteger("signals", &signals)) {
+    DLOG(WARNING) << "missing 'signals' key in mojo message";
+    return nullptr;
+  }
+  int callback_id = 0;
+  if (!args->GetInteger("callbackId", &callback_id)) {
+    DLOG(WARNING) << "missing 'callbackId' key in mojo message";
+    return nullptr;
+  }
+
+  uintptr_t context = WatchCallbackHolder::GetInstance()->Add(^{
+    NSString* signal_watch = [NSString
+        stringWithFormat:@"__crWeb.mojo.mojoWatchSignal(%d);", callback_id];
+    [script_evaluator_ executeJavaScript:signal_watch completionHandler:nil];
+  });
+
+  watch_contexts_.push_back(context);
+
+  return ValueFromMojoInteger(
+      MojoWatch(handle, signals, &MojoWatchCallback, context));
+}
+
+}  // namespace web