Support new-style Mojo JS core API on IOS.

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"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 16 matching lines @@
 #error "This file requires ARC support."
 #endif
 
 namespace web {
 
 namespace {
 
 // Wraps an integer into |base::Value| as |Type::INTEGER|.
 template <typename IntegerT>
 std::unique_ptr<base::Value> ValueFromInteger(IntegerT handle) {
-  return std::unique_ptr<base::Value>(
-      new base::Value(static_cast<int>(handle)));
+  return base::MakeUnique<base::Value>(static_cast<int>(handle));
 }
 
 }  // namespace
 
 MojoFacade::MojoFacade(
     service_manager::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);
 }
 
 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;
   GetMessageNameAndArguments(mojo_message_as_json, &name, &args);
 
   std::unique_ptr<base::Value> result;
-  if (name == "interface_provider.getInterface") {
-    result = HandleInterfaceProviderGetInterface(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());
-  } else if (name == "support.cancelWatch") {
-    result = HandleSupportCancelWatch(args.get());
+  if (name == "Mojo.bindInterface") {
+    result = HandleMojoBindInterface(args.get());
+  } else if (name == "MojoHandle.close") {
+    result = HandleMojoHandleClose(args.get());
+  } else if (name == "Mojo.createMessagePipe") {
+    result = HandleMojoCreateMessagePipe(args.get());
+  } else if (name == "MojoHandle.writeMessage") {
+    result = HandleMojoHandleWriteMessage(args.get());
+  } else if (name == "MojoHandle.readMessage") {
+    result = HandleMojoHandleReadMessage(args.get());
+  } else if (name == "MojoHandle.watch") {
+    result = HandleMojoHandleWatch(args.get());
+  } else if (name == "MojoWatcher.cancel") {
+    result = HandleMojoWatcherCancel(args.get());
   }
 
   if (!result) {
     return "";
   }
 
   std::string json_result;
   base::JSONWriter::Write(*result, &json_result);
   return json_result;
 }
@@ skipping 14 matching lines @@
   std::string name;
   CHECK(mojo_message->GetString("name", &name));
 
   base::DictionaryValue* args = nullptr;
   CHECK(mojo_message->GetDictionary("args", &args));
 
   *out_name = name;
   *out_args = args->CreateDeepCopy();
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleInterfaceProviderGetInterface(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoBindInterface(
     const base::DictionaryValue* args) {
   const base::Value* interface_name_as_value = nullptr;
   CHECK(args->Get("interfaceName", &interface_name_as_value));
+  int raw_handle = 0;
+  CHECK(args->GetInteger("requestHandle", &raw_handle));
+
+  mojo::ScopedMessagePipeHandle handle(
+      static_cast<mojo::MessagePipeHandle>(raw_handle));
 
   // By design interface_provider.getInterface either succeeds or crashes, so
   // check if interface name is a valid string is intentionally omitted.
   std::string interface_name_as_string;
   interface_name_as_value->GetAsString(&interface_name_as_string);
 
-  mojo::MessagePipe pipe;
   interface_provider_->GetInterface(interface_name_as_string,
-                                    std::move(pipe.handle0));
-
-  return ValueFromInteger(pipe.handle1.release().value());
+                                    std::move(handle));
+  return nullptr;
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleCoreClose(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoHandleClose(
     const base::DictionaryValue* args) {
   int handle = 0;
   CHECK(args->GetInteger("handle", &handle));
 
   mojo::Handle(handle).Close();
-
-  return ValueFromInteger(MOJO_RESULT_OK);
+  return nullptr;
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleCoreCreateMessagePipe(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoCreateMessagePipe(
     base::DictionaryValue* args) {
-  const base::Value* options_as_value = nullptr;
-  CHECK(args->Get("optionsDict", &options_as_value));
-
-  if (options_as_value->IsType(base::Value::Type::DICTIONARY)) {
-    // There are no options defined for CreateMessagePipe yet.
-    const base::DictionaryValue* options_as_dict;
-    options_as_value->GetAsDictionary(&options_as_dict);
-    CHECK(options_as_dict->empty());
+  mojo::ScopedMessagePipeHandle handle0, handle1;
+  MojoResult mojo_result = mojo::CreateMessagePipe(nullptr, &handle0, &handle1);
+  auto result = base::MakeUnique<base::DictionaryValue>();
+  result->SetInteger("result", mojo_result);
+  if (mojo_result == MOJO_RESULT_OK) {
+    result->SetInteger("handle0", handle0.release().value());
+    result->SetInteger("handle1", handle1.release().value());
   }
-
-  CHECK(options_as_value->IsType(base::Value::Type::NONE));
-
-  mojo::MessagePipe message_pipe;
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
-  result->SetInteger("handle0", message_pipe.handle0.release().value());
-  result->SetInteger("handle1", message_pipe.handle1.release().value());
   return std::unique_ptr<base::Value>(result.release());
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleCoreWriteMessage(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoHandleWriteMessage(
     base::DictionaryValue* args) {
   int handle = 0;
   CHECK(args->GetInteger("handle", &handle));
 
   base::ListValue* handles_list = nullptr;
   CHECK(args->GetList("handles", &handles_list));
 
   base::DictionaryValue* buffer = nullptr;
   CHECK(args->GetDictionary("buffer", &buffer));
 
-  const base::Value* flags_as_value = nullptr;
-  CHECK(args->Get("flags", &flags_as_value));
-
   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;
   }
 
   mojo::MessagePipeHandle message_pipe(static_cast<MojoHandle>(handle));
   MojoResult result =
       mojo::WriteMessageRaw(message_pipe, bytes.data(), bytes.size(),
                             handles.data(), handles.size(), flags);
 
   return ValueFromInteger(result);
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleCoreReadMessage(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoHandleReadMessage(
     const base::DictionaryValue* args) {
   const base::Value* handle_as_value = nullptr;
   CHECK(args->Get("handle", &handle_as_value));
   int handle_as_int = 0;
   if (!handle_as_value->GetAsInteger(&handle_as_int)) {
     handle_as_int = 0;
   }
 
-  const base::Value* flags_as_value = nullptr;
-  CHECK(args->Get("flags", &flags_as_value));
-
   int flags = MOJO_READ_MESSAGE_FLAG_NONE;
-  if (!flags_as_value->GetAsInteger(&flags)) {
-    flags = MOJO_READ_MESSAGE_FLAG_NONE;
-  }
 
   std::vector<uint8_t> bytes;
   std::vector<mojo::ScopedHandle> handles;
   mojo::MessagePipeHandle handle(static_cast<MojoHandle>(handle_as_int));
   MojoResult mojo_result =
       mojo::ReadMessageRaw(handle, &bytes, &handles, flags);
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+  auto result = base::MakeUnique<base::DictionaryValue>();
   if (mojo_result == MOJO_RESULT_OK) {
-    base::ListValue* handles_list = new base::ListValue;
+    auto handles_list = base::MakeUnique<base::ListValue>();
     for (uint32_t i = 0; i < handles.size(); i++) {
       handles_list->AppendInteger(handles[i].release().value());
     }
-    result->Set("handles", std::unique_ptr<base::Value>(handles_list));
+    result->Set("handles", std::move(handles_list));
 
-    base::ListValue* buffer = new base::ListValue;
+    auto buffer = base::MakeUnique<base::ListValue>();
     for (uint32_t i = 0; i < bytes.size(); i++) {
       buffer->AppendInteger(bytes[i]);
     }
-    result->Set("buffer", std::unique_ptr<base::Value>(buffer));
+    result->Set("buffer", std::move(buffer));
   }
   result->SetInteger("result", mojo_result);
 
   return std::unique_ptr<base::Value>(result.release());
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleSupportWatch(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoHandleWatch(
     const base::DictionaryValue* args) {
   int handle = 0;
   CHECK(args->GetInteger("handle", &handle));
   int signals = 0;
   CHECK(args->GetInteger("signals", &signals));
   int callback_id;
   CHECK(args->GetInteger("callbackId", &callback_id));
 
-  mojo::SimpleWatcher::ReadyCallback callback = base::BindBlockArc(^(
-      MojoResult result) {
-    NSString* script =
-        [NSString stringWithFormat:@"__crWeb.mojo.signalWatch(%d, %d)",
-                                   callback_id, result];
-    [script_evaluator_ executeJavaScript:script completionHandler:nil];
-  });
-  mojo::SimpleWatcher* watcher = new mojo::SimpleWatcher(
+  mojo::SimpleWatcher::ReadyCallback callback =
+      base::BindBlockArc(^(MojoResult result) {
+        NSString* script = [NSString
+            stringWithFormat:
+                @"Mojo.internal.watchCallbacksHolder.callCallback(%d, %d)",
+                callback_id, result];
+        [script_evaluator_ executeJavaScript:script completionHandler:nil];
+      });
+  auto watcher = base::MakeUnique<mojo::SimpleWatcher>(
       FROM_HERE, mojo::SimpleWatcher::ArmingPolicy::AUTOMATIC);
-  watchers_.insert(std::make_pair(++last_watch_id_, base::WrapUnique(watcher)));
   watcher->Watch(static_cast<mojo::Handle>(handle), signals, callback);
+  watchers_.insert(std::make_pair(++last_watch_id_, std::move(watcher)));
   return ValueFromInteger(last_watch_id_);
 }
 
-std::unique_ptr<base::Value> MojoFacade::HandleSupportCancelWatch(
+std::unique_ptr<base::Value> MojoFacade::HandleMojoWatcherCancel(
     const base::DictionaryValue* args) {
   int watch_id = 0;
   CHECK(args->GetInteger("watchId", &watch_id));
   watchers_.erase(watch_id);
   return nullptr;
 }
 
 }  // namespace web