[Presentation API] (3rd) (1-UA) Split PresentationServiceDelegateImpl(PSDImpl)

third_party/WebKit/public/platform/modules/presentation/presentation.mojom

 // Copyright 2015 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.
 
 // TODO(crbug.com/647290): Rename "Session" to "Connection"
 
 module blink.mojom;
 
 import "url/mojo/url.mojom";
 
@@ skipping 34 matching lines @@
 };
 
 struct SessionMessage {
   PresentationMessageType type;
   // Used when message type is TEXT.
   string? message;
   // Used when message type is ARRAY_BUFFER or BLOB.
   array<uint8>? data;
 };
 
+interface PresentationConnection {
+   // TODO(zhaobin): migrate SendSessionMessage from PresentationService =>
+   // PresentationConnection.Send(). http://crbug.com/658474
+
+   // Called to set the PresentationConnection that is the destination for
+   // messages sent and the source of messages received by this connection.
+   SetTargetConnection(PresentationConnection connection);
+
+   // Called when a message is sent by the target connection.
+   OnMessage(SessionMessage message);
+};
+
 interface PresentationService {
   // Sets the PresentationServiceClient.
   SetClient(PresentationServiceClient client);
 
+  ///////////// Functions here are for the controller part of the API. /////////
+
   // Called when the frame sets or changes the default presentation URLs.
   // When the default presentation is started on this frame,
   // PresentationServiceClient::OnDefaultSessionStarted will be invoked.
   SetDefaultPresentationUrls(array<url.mojom.Url> presentation_urls);
 
   // Starts listening for screen availability for presentation of
   // |availability_url|. Availability results will be returned to the client via
   // PresentationServiceClient::OnScreenAvailabilityUpdated.
   ListenForScreenAvailability(url.mojom.Url availability_url);
 
@@ skipping 14 matching lines @@
   StartSession(array<url.mojom.Url> presentation_urls)
       => (PresentationSessionInfo? sessionInfo, PresentationError? error);
 
   // Called when joinSession() is called by the frame. The result callback
   // works the same as for the method above. JoinSession will join a known
   // session (i.e. when the page navigates or the user opens another tab)
   // silently and without user action.
   JoinSession(array<url.mojom.Url> presentation_urls, string? presentation_id)
       => (PresentationSessionInfo? sessionInfo, PresentationError? error);
 
+  // Called in StartSession's callback function for offscreen presentation only.
+  // It passes in controlling frame's PresentationConnection to
+  // PresentationService.
+  SetPresentationConnection(PresentationSessionInfo sessionInfo,
+                            PresentationConnection connection);

[dcheng, 2017/01/06 11:54:22]

As far as I can tell, the goal is a 1:1 relationship of PresentationConnection
objects: we only need to associate a PresentationConnection in the renderer
starting the presentation with the PresentationConnection object in the
offscreen presentation. So my only big suggestion is to try to remove
SetTargetConnection() to simplify the exposed API in Mojo. Right now, this
method can be called at anytime, it's harder to understand how different
PresentationConnections can be related.

Is it possible to pass a PresentationConnection + PresentationConnection& pair
here? In C++, this would translate to a PresentationConnectionPtr and a
PresentationConnectionRequest.

In C++, in the renderer starting the presentation, we would create the proxy
connection:
  auto proxy = base::MakeUnique<PresentationConnectionProxy>();

then we would create PresentationConnectionRequest:
  auto remote_connection_request = proxy->MakeRemoteRequest();

and then we pass both the interface pointer to the created proxy, as well as the
interface request that the remote end will connect:

  service->SetPresentationConnection(info, proxy->Bind(),
      std::move(remote_connection_request));

On the browser side, the |remote_connection_request| is passed to the offscreen
presentation, which binds it to the PresentationConnection impl it creates,
completing the connection.

The MakeRemoteRequest() helper implementation would look like this:
PresentationConnectionRequest
PresentationConnectionProxy::MakeRemoteRequest() {
  DCHECK(!target_connection_)
      << "target_connection_ should only be bound once.";
  return mojo::MakeRequest(&target_connection_);
}

[zhaobin, 2017/01/10 01:39:17]

Done.

[mark a. foltz, 2017/01/10 23:05:33]

I agree it would be slightly better to have an API where it's clear that
connection passing happens once.  However it comes at the expense of adding a
connection request struct to the API, which is really more general than we need
to implement offscreen presentations.

I think there are other ways to solve this.  For example PresentationSessionInfo
could have an optional PresentationConnectionPtr for the target connection
(which could be set on the callback to StartSession, instead of through a
separate method).  However, I don't think additional bike shedding is going to
help much, and effort is better spent on documenting the current solution.

[dcheng, 2017/01/11 09:22:18]

I'm not familiar enough with how the presentation mojo interfaces are setup.
This suggestion does sound better to me, but I'm OK with this CL as-is as well.
If you don't mind CCing me in followups, I'm a bit curious how this will end up
looking.

+
+  //////////////////////////////////////////////////////////////////////////////
+
   // Called when send() is called by the frame. The true in the
   // result callback notifies that the service is ready for next message.
   // The false in the result callback notifies the renderer to stop sending
   // the send requests and invalidate all pending requests. This occurs
   // for eg., when frame is deleted or navigated away.
   SendSessionMessage(PresentationSessionInfo sessionInfo,
                      SessionMessage message_request) => (bool success);
 
   // Called when close() is called by the frame.
   CloseConnection(url.mojom.Url presentation_url, string presentation_id);
@@ skipping 35 matching lines @@
   // See PresentationService::ListenForSessionMessages.
   OnSessionMessagesReceived(PresentationSessionInfo sessionInfo,
                             array<SessionMessage> messages);
 
   // See PresentationService::SetDefaultPresentationURL.
   OnDefaultSessionStarted(PresentationSessionInfo sessionInfo);
 
   // See PresentationService::OnReceiverConnectionAvailable.
   OnReceiverConnectionAvailable(PresentationSessionInfo sessionInfo);
 };