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

content/browser/presentation/presentation_service_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_
 #define CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_
 
 #include <deque>
 #include <map>
 #include <memory>
@@ skipping 30 matching lines @@
 // It handles Presentation API requests coming from Blink / renderer process
 // and delegates the requests to the embedder's media router via
 // PresentationServiceDelegate.
 // An instance of this class tied to a RenderFrameHost and listens to events
 // related to the RFH via implementing WebContentsObserver.
 // This class is instantiated on-demand via Mojo's ConnectToRemoteService
 // from the renderer when the first presentation API request is handled.
 class CONTENT_EXPORT PresentationServiceImpl
     : public NON_EXPORTED_BASE(blink::mojom::PresentationService),
       public WebContentsObserver,
-      public PresentationServiceDelegate::Observer {
+      public PresentationServiceDelegateBase::Observer {
  public:
   using NewSessionCallback =
       base::Callback<void(blink::mojom::PresentationSessionInfoPtr,
                           blink::mojom::PresentationErrorPtr)>;
 
   ~PresentationServiceImpl() override;
 
   // Static factory method to create an instance of PresentationServiceImpl.
   // |render_frame_host|: The RFH the instance is associated with.
   // |request|: The instance will be bound to this request. Used for Mojo setup.
@@ skipping 26 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
                            ReceiveSessionMessagesAfterReset);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
                            MaxPendingStartSessionRequests);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
                            MaxPendingJoinSessionRequests);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
                            ListenForConnectionStateChangeAndChangeState);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
                            ListenForConnectionClose);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
+                           SetPresentationConnection);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
+                           ReceiverPresentationServiceDelegate);
 
   // Maximum number of pending JoinSession requests at any given time.
   static const int kMaxNumQueuedSessionRequests = 10;
 
   using SessionMessagesCallback =
       base::Callback<void(mojo::Array<blink::mojom::SessionMessagePtr>)>;
   using SendSessionMessageCallback = base::Callback<void(bool)>;
 
   // Listener implementation owned by PresentationServiceImpl. An instance of
   // this is created when PresentationRequest.getAvailability() is resolved.
@@ skipping 28 matching lines @@
              blink::mojom::PresentationErrorPtr error);
 
    private:
     NewSessionCallback callback_;
 
     DISALLOW_COPY_AND_ASSIGN(NewSessionCallbackWrapper);
   };
 
   // |render_frame_host|: The RFH this instance is associated with.
   // |web_contents|: The WebContents to observe.
-  // |delegate|: Where Presentation API requests are delegated to. Not owned
+  // |controller_delegate|: Where Presentation API requests are delegated to in
+  // controller frame. Set to null if current frame is receiver frame. Not owned
+  // by this class.
+  // |receiver_delegate|: Where Presentation API requests are delegated to in
+  // receiver frame. Set to null if current frame is controller frame. Not owned
   // by this class.
   PresentationServiceImpl(
       RenderFrameHost* render_frame_host,
       WebContents* web_contents,
-      PresentationServiceDelegate* delegate);
+      ControllerPresentationServiceDelegate* controller_delegate,
+      ReceiverPresentationServiceDelegate* receiver_delegate);

[mark a. foltz, 2016/11/15 23:41:47]

Can this ctor now be made private?

[zhaobin, 2016/11/16 18:02:42]

Yes. The constructor and all functions below it are private.

 
   // PresentationService implementation.
   void SetDefaultPresentationUrls(
       const std::vector<GURL>& presentation_urls) override;
   void SetClient(blink::mojom::PresentationServiceClientPtr client) override;
   void ListenForScreenAvailability(const GURL& url) override;
   void StopListeningForScreenAvailability(const GURL& url) override;
   void StartSession(const std::vector<GURL>& presentation_urls,
                     const NewSessionCallback& callback) override;
   void JoinSession(const std::vector<GURL>& presentation_urls,
                    const base::Optional<std::string>& presentation_id,
                    const NewSessionCallback& callback) override;
   void SendSessionMessage(blink::mojom::PresentationSessionInfoPtr session_info,
                           blink::mojom::SessionMessagePtr session_message,
                           const SendSessionMessageCallback& callback) override;
   void CloseConnection(const GURL& presentation_url,
                        const std::string& presentation_id) override;
   void Terminate(const GURL& presentation_url,
                  const std::string& presentation_id) override;
   void ListenForSessionMessages(
       blink::mojom::PresentationSessionInfoPtr session) override;
+  void SetPresentationConnection(
+      blink::mojom::PresentationSessionInfoPtr session,
+      blink::mojom::PresentationConnectionPtr connection) override;
 
   // Creates a binding between this object and |request|.
   void Bind(mojo::InterfaceRequest<blink::mojom::PresentationService> request);
 
   // WebContentsObserver override.
   void DidNavigateAnyFrame(
       content::RenderFrameHost* render_frame_host,
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override;
   void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
@@ skipping 37 matching lines @@
       int request_session_id,
       const PresentationError& error);
   void OnSendMessageCallback(bool sent);
 
   // Calls to |delegate_| to start listening for state changes for |connection|.
   // State changes will be returned via |OnConnectionStateChanged|. Change
   // |connection|'s state to 'connected' after listening.
   void ListenForConnectionStateChangeAndChangeState(
       const PresentationSessionInfo& connection);
 
-  // Passed to embedder's implementation of PresentationServiceDelegate for
-  // later invocation when session messages arrive.
   void OnSessionMessages(
       const content::PresentationSessionInfo& session,
       const ScopedVector<PresentationSessionMessage>& messages,
       bool pass_ownership);
 
+  // A callback registered to OffscreenPresentationManager when
+  // the PresentationServiceImpl for the presentation receiver is initialized.
+  // Calls |client_| to create a new PresentationConnection on receiver page.
+  void OnReceiverConnectionAvailable(
+      const content::PresentationSessionInfo& session_info,
+      PresentationConnectionPtr&& controller_connection);
+
   // Associates a JoinSession |callback| with a unique request ID and
   // stores it in a map.
   // Returns a positive value on success.
   int RegisterJoinSessionCallback(const NewSessionCallback& callback);
 
   // Invoked by the embedder's PresentationServiceDelegate when a
   // PresentationConnection's state has changed.
   void OnConnectionStateChanged(
       const PresentationSessionInfo& connection,
       const PresentationConnectionStateChangeInfo& info);
 
   // Returns true if this object is associated with |render_frame_host|.
   bool FrameMatches(content::RenderFrameHost* render_frame_host) const;
 
-  // Embedder-specific delegate to forward Presentation requests to.
-  // May be null if embedder does not support Presentation API.
-  PresentationServiceDelegate* delegate_;
+  // Returns |controller_delegate| if current frame is controller frame; Returns
+  // |receiver_delegate| if current frame is receiver frame.
+  PresentationServiceDelegateBase* GetPresentationServiceDelegate();
+
+  // Embedder-specific delegate for controller to forward Presentation requests
+  // to. Must be nullptr if current page is receiver page or
+  // embedder does not support Presentation API .
+  ControllerPresentationServiceDelegate* controller_delegate_;
+
+  // Embedder-specific delegate for receiver to forward Presentation requests
+  // to. Must be nullptr if current page is receiver page or
+  // embedder does not support Presentation API.
+  ReceiverPresentationServiceDelegate* receiver_delegate_;
 
   // Proxy to the PresentationServiceClient to send results (e.g., screen
   // availability) to.
   blink::mojom::PresentationServiceClientPtr client_;
 
   std::vector<GURL> default_presentation_urls_;
 
   using ScreenAvailabilityListenerMap =
       std::map<GURL, std::unique_ptr<ScreenAvailabilityListenerImpl>>;
   ScreenAvailabilityListenerMap screen_availability_listeners_;
@@ skipping 22 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<PresentationServiceImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationServiceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_