(SUSPENDED) SharedWorker: Mojofy Renderer(Document)->Browser communication for SharedWorker

content/common/shared_worker.mojom

Index: content/common/shared_worker.mojom
diff --git a/content/common/shared_worker.mojom b/content/common/shared_worker.mojom
new file mode 100644
index 0000000000000000000000000000000000000000..52fb06647e776410268e0ad09f313aa335c79b10
--- /dev/null
+++ b/content/common/shared_worker.mojom
@@ -0,0 +1,72 @@
+// 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.
+
+module content.mojom;
+
+import "mojo/common/string16.mojom";
+import "url/mojo/url.mojom";
+
+[Native]
+enum WebContentSecurityPolicyType;
+
+[Native]
+enum WebSharedWorkerCreationContextType;
+
+[Native]
+enum WebAddressSpace;
+
+[Native]
+enum WebWorkerCreationError;
+
+struct SharedWorkerCreateParams {
+  // URL for the worker script.
+  url.mojom.Url url;
+
+  // Name for a SharedWorker, otherwise empty string.
+  mojo.common.mojom.String16 name;
+
+  // Security policy used in the worker.
+  mojo.common.mojom.String16 content_security_policy;
+
+  // Security policy type used in the worker.
+  WebContentSecurityPolicyType security_policy_type;
+
+  // The ID of the parent document (unique within parent renderer).
+  uint64 document_id;
+
+  // RenderFrame routing id used to send messages back to the parent.
+  int32 render_frame_route_id;
+
+  // Address space of the context that created the worker.
+  WebAddressSpace creation_address_space;
+
+  // The type (secure or nonsecure) of the context that created the worker.
+  WebSharedWorkerCreationContextType creation_context_type;
+};
+
+// Per-process browser-side interface bound to SharedWorkerMessageFilter.
+// Each InterfacePtrs on the same render process will be bound to the same

[kinuko, 2017/01/11 06:06:43]

nit: Each InterfacePtrs -> Each InterfacePtr or All InterfacePtrs

+// SharedWorkerMessageFilter.
+interface SharedWorkerMessageFilter {
+  // A renderer calls this to the browser process when it wants to create a
+  // worker. The browser will create the worker process if necessary, and
+  // will return the route id.
+  // TODO(nhiroki): This route id will be removed when
+  // browser->renderer(document) communication is mojofied.
+  // (https://crbug.com/612308)
+  // TODO(nhiroki): Make this asynchronous (https://crbug.com/679654).

[kinuko, 2017/01/11 06:06:43]

I feel we could do the necessary refactoring to make it work asyncly first
(without changing IPC change) and then introduce mojo, then we don't need to
introduce controversial sync IPC changes in new mojo code.  Up to you but worth
considering.

[nhiroki, 2017/01/11 07:48:56]

Hmmm... I tried this and was stuck. How do we notify WebSharedWorkerProxy of
route_id in response to a worker creation message? WebSharedWorkerProxy needs
route_id to receive a message, but route_id is notified via a message. I came up
with using a temporary route_id generated in a renderer-side, but found this
confuses MessageRouter. Do you have any ideas on this?

This could be easier resolved after mojofication. WebSharedWorkerProxy can send
a mojofied object like shimazu's comment to SharedWorkerMessageFilter, and the
filter can reply to the proxy over the mojofied object.

[kinuko, 2017/01/11 11:51:46]

I have imagined that we do necessary refactoring for async/mojo-fying first just
with the given route_id, e.g.  createSharedWorkerConnector directly takes
ConnectListener and we can immediately do connect() operation without returning
WebSharedWorkerConnector to blink code etc.
I agree with it.  But then it feels it's more straightforward to mojofy
OnCreateWorker with the rest of mojofication work?  (We'll need to change
OnCreateWorker in the next patch too anyways)

[nhiroki, 2017/01/12 04:05:27]

Ah, I understand what you mean. You mean the following 2-steps, right?

  (1) Refactoring SharedWorkerConnector/WebSharedWorkerConnector
  (2) Making it async with introducing mojo

I misread your comment as following steps :p

  (1) Refactoring them and making it async
  (2) Introducing mojo

Your idea sounds reasonable. I'll make a separate refactoring CL.

+  [Sync]
+  OnCreateWorker(SharedWorkerCreateParams params)
+      => (int32 route_id, WebWorkerCreationError error);
+
+  // A renderer calls this to the browser process when a document has been
+  // detached. The browser will use this to constrain the lifecycle of the
+  // renderer process where the associated worker runs (SharedWorkers are shut
+  // down when their last associated document is detached).
+  OnDocumentDetached(uint64 document_id);
+
+  // A renderer sends this to the browser process when it wants to connect to
+  // the worker that is specified by the route id.
+  OnConnectToWorker(int32 route_id, int32 sent_message_port_id);
+};