[Presentation API] Replaces type converters with typemaps

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 32 matching lines @@
 // 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:
+  ~PresentationServiceImpl() override;
+
   using NewSessionCallback =
-      base::Callback<void(blink::mojom::PresentationSessionInfoPtr,
-                          blink::mojom::PresentationErrorPtr)>;
-
-  ~PresentationServiceImpl() override;
+      base::Callback<void(const base::Optional<PresentationSessionInfo>&,
+                          const base::Optional<PresentationError>&)>;
 
   // 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.
   static void CreateMojoService(
       RenderFrameHost* render_frame_host,
       mojo::InterfaceRequest<blink::mojom::PresentationService> request);
 
  private:
   friend class PresentationServiceImplTest;
@@ skipping 61 matching lines @@
   };
 
   // Ensures the provided NewSessionCallback is invoked exactly once
   // before it goes out of scope.
   class NewSessionCallbackWrapper {
    public:
     explicit NewSessionCallbackWrapper(
         const NewSessionCallback& callback);
     ~NewSessionCallbackWrapper();
 
-    void Run(blink::mojom::PresentationSessionInfoPtr session,
-             blink::mojom::PresentationErrorPtr error);
+    void Run(const base::Optional<PresentationSessionInfo>& session_info,
+             const base::Optional<PresentationError>& 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.
   // |controller_delegate|: Where Presentation API requests are delegated to in
@@ skipping 13 matching lines @@
       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 SendConnectionMessage(
-      blink::mojom::PresentationSessionInfoPtr session_info,
+      const PresentationSessionInfo& session_info,
       blink::mojom::ConnectionMessagePtr connection_message,
       const SendConnectionMessageCallback& 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 ListenForConnectionMessages(
-      blink::mojom::PresentationSessionInfoPtr session) override;
+      const PresentationSessionInfo& session_info) override;
   void SetPresentationConnection(
-      blink::mojom::PresentationSessionInfoPtr session,
+      const PresentationSessionInfo& session_info,
       blink::mojom::PresentationConnectionPtr controller_connection_ptr,
       blink::mojom::PresentationConnectionRequest receiver_connection_request)
       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;
   void WebContentsDestroyed() override;
 
   // PresentationServiceDelegate::Observer
   void OnDelegateDestroyed() override;
 
   // Passed to embedder's implementation of PresentationServiceDelegate for
   // later invocation when default presentation has started.
   void OnDefaultPresentationStarted(
       const PresentationSessionInfo& session_info);
 
   // Finds the callback from |pending_join_session_cbs_| using
   // |request_session_id|.
-  // If it exists, invoke it with |session| and |error|, then erase it from
+  // If it exists, invoke it with |session_info| and |error|, then erase it from
   // |pending_join_session_cbs_|.
   // Returns true if the callback was found.
   bool RunAndEraseJoinSessionMojoCallback(
       int request_session_id,
-      blink::mojom::PresentationSessionInfoPtr session,
-      blink::mojom::PresentationErrorPtr error);
+      const base::Optional<PresentationSessionInfo>& session_info,
+      const base::Optional<PresentationError>& error);
 
   // Removes all listeners and resets default presentation URL on this instance
   // and informs the PresentationServiceDelegate of such.
   void Reset();
 
   // These functions are bound as base::Callbacks and passed to
   // embedder's implementation of PresentationServiceDelegate for later
   // invocation.
   void OnStartSessionSucceeded(
       int request_session_id,
@@ skipping 11 matching lines @@
 
   // 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 OnConnectionMessages(
-      const content::PresentationSessionInfo& session,
+      const content::PresentationSessionInfo& session_info,
       const std::vector<std::unique_ptr<PresentationConnectionMessage>>&
           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_ptr,
@@ skipping 61 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_