[Presentation API] Replaces type converters with typemaps

content/renderer/presentation/presentation_dispatcher_unittest.cc

 // 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 <memory>
 #include <utility>
 
 #include "base/run_loop.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/renderer/presentation/presentation_connection_proxy.h"
@@ skipping 13 matching lines @@
 using blink::WebArrayBuffer;
 using blink::WebPresentationAvailabilityCallbacks;
 using blink::WebPresentationAvailabilityObserver;
 using blink::WebPresentationConnectionCallbacks;
 using blink::WebPresentationError;
 using blink::WebPresentationSessionInfo;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 using blink::mojom::PresentationConnection;
-using blink::mojom::PresentationError;
-using blink::mojom::PresentationErrorPtr;
-using blink::mojom::PresentationErrorType;
 using blink::mojom::PresentationService;
 using blink::mojom::PresentationServiceClientPtr;
-using blink::mojom::PresentationSessionInfo;
-using blink::mojom::PresentationSessionInfoPtr;
 using blink::mojom::ConnectionMessage;
 using blink::mojom::ConnectionMessagePtr;
 
 // TODO(crbug.com/576808): Add test cases for the following:
 // - State changes
 // - Messages received
 // - Discarding queued messages when the frame navigates
 // - Screen availability not supported
 // - Default presentation starting
 
@@ skipping 25 matching lines @@
                void(const std::vector<GURL>& presentation_urls,
                     const StartSessionCallback& callback));
   MOCK_METHOD3(JoinSession,
                void(const std::vector<GURL>& presentation_urls,
                     const base::Optional<std::string>& presentation_id,
                     const JoinSessionCallback& callback));
 
   // *Internal method is to work around lack of support for move-only types in
   // GMock.
   void SendConnectionMessage(
-      PresentationSessionInfoPtr session_info,
+      const PresentationSessionInfo& session_info,
       ConnectionMessagePtr message_request,
       const SendConnectionMessageCallback& callback) override {
-    SendConnectionMessageInternal(session_info.get(), message_request.get(),
+    SendConnectionMessageInternal(session_info, message_request.get(),
                                   callback);
   }
   MOCK_METHOD3(SendConnectionMessageInternal,
-               void(PresentationSessionInfo* session_info,
+               void(const PresentationSessionInfo& session_info,
                     ConnectionMessage* message_request,
                     const SendConnectionMessageCallback& callback));
 
   MOCK_METHOD2(CloseConnection,
                void(const GURL& presentation_url,
                     const std::string& presentation_id));
   MOCK_METHOD2(Terminate,
                void(const GURL& presentation_url,
                     const std::string& presentation_id));
 
-  // *Internal method is to work around lack of support for move-only types in
-  // GMock.
-  void ListenForConnectionMessages(
-      PresentationSessionInfoPtr session_info) override {
-    ListenForConnectionMessagesInternal(session_info.get());
-  }
-  MOCK_METHOD1(ListenForConnectionMessagesInternal,
-               void(PresentationSessionInfo* session_info));
+  MOCK_METHOD1(ListenForConnectionMessages,
+               void(const PresentationSessionInfo& session_info));
 
   void SetPresentationConnection(
-      blink::mojom::PresentationSessionInfoPtr session,
+      const PresentationSessionInfo& session_info,
       blink::mojom::PresentationConnectionPtr controller_conn_ptr,
       blink::mojom::PresentationConnectionRequest receiver_conn_request)
       override {
-    SetPresentationConnection(session.get(), controller_conn_ptr.get());
+    SetPresentationConnection(session_info, controller_conn_ptr.get());
   }
   MOCK_METHOD2(SetPresentationConnection,
-               void(PresentationSessionInfo* session_info,
+               void(const PresentationSessionInfo& session_info,
                     PresentationConnection* connection));
 };
 
 class MockPresentationAvailabilityCallbacks
     : public blink::WebCallbacks<bool, const blink::WebPresentationError&> {
  public:
   MOCK_METHOD1(onSuccess, void(bool value));
   MOCK_METHOD1(onError, void(const blink::WebPresentationError&));
 };
 
@@ skipping 173 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(PresentationDispatcherTest, TestStartSession) {
   base::RunLoop run_loop;
 
   EXPECT_CALL(presentation_service_, StartSession(gurls_, _))
       .WillOnce(Invoke([this](
           const std::vector<GURL>& presentation_urls,
           const PresentationService::StartSessionCallback& callback) {
-        PresentationSessionInfoPtr session_info(PresentationSessionInfo::New());
-        session_info->url = gurl1_;
-        session_info->id = presentation_id_.utf8();
-        callback.Run(std::move(session_info), PresentationErrorPtr());
+        PresentationSessionInfo session_info(gurl1_, presentation_id_.utf8());
+        callback.Run(session_info, base::nullopt);
       }));
   client()->startSession(
       urls_, base::MakeUnique<TestWebPresentationConnectionCallback>(
                  url1_, presentation_id_));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestStartSessionError) {
   WebString error_message = WebString::fromUTF8("Test error message");
   base::RunLoop run_loop;
 
   EXPECT_CALL(presentation_service_, StartSession(gurls_, _))
       .WillOnce(Invoke([&error_message](
           const std::vector<GURL>& presentation_urls,
           const PresentationService::StartSessionCallback& callback) {
-        PresentationErrorPtr error(PresentationError::New());
-        error->error_type = PresentationErrorType::NO_AVAILABLE_SCREENS;
-        error->message = error_message.utf8();
-        callback.Run(PresentationSessionInfoPtr(), std::move(error));
+        callback.Run(
+            base::nullopt,
+            PresentationError(content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
+                              error_message.utf8()));
       }));
   client()->startSession(
       urls_,
       base::MakeUnique<TestWebPresentationConnectionErrorCallback>(
           WebPresentationError::ErrorTypeNoAvailableScreens, error_message));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestJoinSessionError) {
   WebString error_message = WebString::fromUTF8("Test error message");
   base::RunLoop run_loop;
 
   EXPECT_CALL(presentation_service_, JoinSession(gurls_, _, _))
       .WillOnce(Invoke([this, &error_message](
           const std::vector<GURL>& presentation_urls,
           const base::Optional<std::string>& presentation_id,
           const PresentationService::JoinSessionCallback& callback) {
         EXPECT_TRUE(presentation_id.has_value());
         EXPECT_EQ(presentation_id_.utf8(), presentation_id.value());
-        PresentationErrorPtr error(PresentationError::New());
-        error->error_type = PresentationErrorType::NO_AVAILABLE_SCREENS;
-        error->message = error_message.utf8();
-        callback.Run(PresentationSessionInfoPtr(), std::move(error));
+        callback.Run(
+            base::nullopt,
+            PresentationError(content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
+                              error_message.utf8()));
       }));
   dispatcher_.joinSession(
       urls_, presentation_id_,
       base::MakeUnique<TestWebPresentationConnectionErrorCallback>(
           WebPresentationError::ErrorTypeNoAvailableScreens, error_message));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestJoinSession) {
   base::RunLoop run_loop;
 
   EXPECT_CALL(presentation_service_, JoinSession(gurls_, _, _))
       .WillOnce(Invoke([this](
           const std::vector<GURL>& presentation_urls,
           const base::Optional<std::string>& presentation_id,
           const PresentationService::JoinSessionCallback& callback) {
         EXPECT_TRUE(presentation_id.has_value());
         EXPECT_EQ(presentation_id_.utf8(), presentation_id.value());
-        PresentationSessionInfoPtr session_info(PresentationSessionInfo::New());
-        session_info->url = gurl1_;
-        session_info->id = presentation_id_.utf8();
-        callback.Run(std::move(session_info), PresentationErrorPtr());
+        callback.Run(PresentationSessionInfo(gurl1_, presentation_id_.utf8()),
+                     base::nullopt);
       }));
   dispatcher_.joinSession(
       urls_, presentation_id_,
       base::MakeUnique<TestWebPresentationConnectionCallback>(
           url1_, presentation_id_));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendString) {
   WebString message = WebString::fromUTF8("test message");
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
       .WillOnce(Invoke([this, &message](
-          PresentationSessionInfo* session_info,
+          const PresentationSessionInfo& session_info,
           ConnectionMessage* message_request,
           const PresentationService::SendConnectionMessageCallback& callback) {
-        EXPECT_EQ(gurl1_, session_info->url);
-        EXPECT_EQ(presentation_id_.utf8(), session_info->id);
+        EXPECT_EQ(gurl1_, session_info.presentation_url);
+        EXPECT_EQ(presentation_id_.utf8(), session_info.presentation_id);
         EXPECT_TRUE(message_request->message.has_value());
         EXPECT_EQ(message.utf8(), message_request->message.value());
         callback.Run(true);
       }));
   dispatcher_.sendString(url1_, presentation_id_, message, nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendArrayBuffer) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
       .WillOnce(Invoke([this](
-          PresentationSessionInfo* session_info,
+          const PresentationSessionInfo& session_info,
           ConnectionMessage* message_request,
           const PresentationService::SendConnectionMessageCallback& callback) {
-        EXPECT_EQ(gurl1_, session_info->url);
-        EXPECT_EQ(presentation_id_.utf8(), session_info->id);
+        EXPECT_EQ(gurl1_, session_info.presentation_url);
+        EXPECT_EQ(presentation_id_.utf8(), session_info.presentation_id);
         std::vector<uint8_t> data(
             array_buffer_data(),
             array_buffer_data() + array_buffer_.byteLength());
         EXPECT_TRUE(message_request->data.has_value());
         EXPECT_EQ(data, message_request->data.value());
         callback.Run(true);
       }));
   dispatcher_.sendArrayBuffer(url1_, presentation_id_, array_buffer_data(),
                               array_buffer_.byteLength(), nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendBlobData) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
       .WillOnce(Invoke([this](
-          PresentationSessionInfo* session_info,
+          const PresentationSessionInfo& session_info,
           ConnectionMessage* message_request,
           const PresentationService::SendConnectionMessageCallback& callback) {
-        EXPECT_EQ(gurl1_, session_info->url);
-        EXPECT_EQ(presentation_id_.utf8(), session_info->id);
+        EXPECT_EQ(gurl1_, session_info.presentation_url);
+        EXPECT_EQ(presentation_id_.utf8(), session_info.presentation_id);
         std::vector<uint8_t> data(
             array_buffer_data(),
             array_buffer_data() + array_buffer_.byteLength());
         EXPECT_TRUE(message_request->data.has_value());
         EXPECT_EQ(data, message_request->data.value());
         callback.Run(true);
       }));
   dispatcher_.sendBlobData(url1_, presentation_id_, array_buffer_data(),
                            array_buffer_.byteLength(), nullptr);
   run_loop.RunUntilIdle();
@@ skipping 278 matching lines @@
 
   for (auto* mock_observer : mock_observers_)
     EXPECT_CALL(*mock_observer, availabilityChanged(false));
 
   base::RunLoop run_loop_2;
   ChangeURLState(gurl2_, URLState::Unavailable);
   run_loop_2.RunUntilIdle();
 }
 
 }  // namespace content