third_party/WebKit/Source/core/mojo/Mojo.cpp

// Copyright 2017 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 "core/mojo/Mojo.h"

#include <string>

#include "core/dom/Document.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/LocalFrameClient.h"
#include "core/mojo/MojoCreateDataPipeOptions.h"
#include "core/mojo/MojoCreateDataPipeResult.h"
#include "core/mojo/MojoCreateMessagePipeResult.h"
#include "core/mojo/MojoCreateSharedBufferResult.h"
#include "core/mojo/MojoHandle.h"
#include "core/workers/WorkerGlobalScope.h"
#include "core/workers/WorkerThread.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "platform/bindings/ScriptState.h"
#include "platform/wtf/text/StringUTF8Adaptor.h"
#include "public/platform/InterfaceProvider.h"
#include "public/platform/Platform.h"
#include "services/service_manager/public/cpp/interface_provider.h"

namespace blink {

// static
void Mojo::createMessagePipe(MojoCreateMessagePipeResult& result_dict) {
  MojoCreateMessagePipeOptions options = {0};
  options.struct_size = sizeof(::MojoCreateMessagePipeOptions);
  options.flags = MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE;

  mojo::ScopedMessagePipeHandle handle0, handle1;
  MojoResult result = mojo::CreateMessagePipe(&options, &handle0, &handle1);

  result_dict.setResult(result);
  if (result == MOJO_RESULT_OK) {
    result_dict.setHandle0(
        MojoHandle::Create(mojo::ScopedHandle::From(std::move(handle0))));
    result_dict.setHandle1(
        MojoHandle::Create(mojo::ScopedHandle::From(std::move(handle1))));
  }
}

// static
void Mojo::createDataPipe(const MojoCreateDataPipeOptions& options_dict,
                          MojoCreateDataPipeResult& result_dict) {
  if (!options_dict.hasElementNumBytes() ||
      !options_dict.hasCapacityNumBytes()) {
    result_dict.setResult(MOJO_RESULT_INVALID_ARGUMENT);
    return;
  }

  ::MojoCreateDataPipeOptions options = {0};
  options.struct_size = sizeof(options);
  options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
  options.element_num_bytes = options_dict.elementNumBytes();
  options.capacity_num_bytes = options_dict.capacityNumBytes();

  mojo::ScopedDataPipeProducerHandle producer;
  mojo::ScopedDataPipeConsumerHandle consumer;
  MojoResult result = mojo::CreateDataPipe(&options, &producer, &consumer);
  result_dict.setResult(result);
  if (result == MOJO_RESULT_OK) {
    result_dict.setProducer(
        MojoHandle::Create(mojo::ScopedHandle::From(std::move(producer))));
    result_dict.setConsumer(
        MojoHandle::Create(mojo::ScopedHandle::From(std::move(consumer))));
  }
}

// static
void Mojo::createSharedBuffer(unsigned num_bytes,
                              MojoCreateSharedBufferResult& result_dict) {
  MojoCreateSharedBufferOptions* options = nullptr;
  mojo::Handle handle;
  MojoResult result =
      MojoCreateSharedBuffer(options, num_bytes, handle.mutable_value());

  result_dict.setResult(result);
  if (result == MOJO_RESULT_OK) {
    result_dict.setHandle(MojoHandle::Create(mojo::MakeScopedHandle(handle)));
  }
}

// static
void Mojo::bindInterface(ScriptState* script_state,
                         const String& interface_name,
                         MojoHandle* request_handle,
                         const String& scope) {
  std::string name =
      StringUTF8Adaptor(interface_name).AsStringPiece().as_string();
  auto handle =
      mojo::ScopedMessagePipeHandle::From(request_handle->TakeHandle());

  if (scope == "process") {
    Platform::Current()->GetInterfaceProvider()->GetInterface(
        name.c_str(), std::move(handle));
    return;
  }

  if (auto* interface_provider =
          ExecutionContext::From(script_state)->GetInterfaceProvider()) {
    interface_provider->GetInterfaceByName(name, std::move(handle));
  }
}

}  // namespace blink