[Presentation API] Mojo typemap for content::PresentationConnectionMessage

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/common/presentation_connection_message.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/renderer/presentation/presentation_connection_proxy.h"
 #include "content/renderer/presentation/presentation_dispatcher.h"
 #include "content/renderer/presentation/test_presentation_connection.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnection.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnectionCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationReceiver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationSessionInfo.h"
 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 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::PresentationService;
 using blink::mojom::PresentationServiceClientPtr;
-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
 
 namespace content {
 
@@ skipping 20 matching lines @@
   MOCK_METHOD1(StopListeningForScreenAvailability,
                void(const GURL& availability_url));
   MOCK_METHOD2(StartSession,
                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(
-      const PresentationSessionInfo& session_info,
-      ConnectionMessagePtr message_request,
-      const SendConnectionMessageCallback& callback) override {
-    SendConnectionMessageInternal(session_info, message_request.get(),
-                                  callback);
-  }
-  MOCK_METHOD3(SendConnectionMessageInternal,
+  MOCK_METHOD3(SendConnectionMessage,
                void(const PresentationSessionInfo& session_info,
-                    ConnectionMessage* message_request,
+                    const PresentationConnectionMessage& 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));
 
   MOCK_METHOD1(ListenForConnectionMessages,
                void(const PresentationSessionInfo& session_info));
 
   void SetPresentationConnection(
       const PresentationSessionInfo& session_info,
       blink::mojom::PresentationConnectionPtr controller_conn_ptr,
       blink::mojom::PresentationConnectionRequest receiver_conn_request)
       override {
     SetPresentationConnection(session_info, controller_conn_ptr.get());
   }
   MOCK_METHOD2(SetPresentationConnection,
                void(const PresentationSessionInfo& session_info,
                     PresentationConnection* connection));
 };
 
 class TestPresentationConnectionProxy : public PresentationConnectionProxy {
  public:
   TestPresentationConnectionProxy(blink::WebPresentationConnection* connection)
       : PresentationConnectionProxy(connection) {}
 
-  void SendConnectionMessage(blink::mojom::ConnectionMessagePtr session_message,
-                             const OnMessageCallback& callback) const override {
-    SendConnectionMessageInternal(session_message.get(), callback);
-  }
-  MOCK_CONST_METHOD2(SendConnectionMessageInternal,
-                     void(blink::mojom::ConnectionMessage*,
+  MOCK_CONST_METHOD2(SendConnectionMessage,
+                     void(const PresentationConnectionMessage&,
                           const OnMessageCallback&));
 };
 
 class TestPresentationReceiver : public blink::WebPresentationReceiver {
  public:
   blink::WebPresentationConnection* onReceiverConnectionAvailable(
       const blink::WebPresentationSessionInfo&) override {
     return &connection_;
   }
 
@@ skipping 279 matching lines @@
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(connection.proxy());
 }
 
 TEST_F(PresentationDispatcherTest, TestSendString) {
   WebString message = WebString::fromUTF8("test message");
   TestPresentationConnection connection;
   TestPresentationConnectionProxy connection_proxy(&connection);
 
+  PresentationConnectionMessage expected_message(message.utf8());
+
   base::RunLoop run_loop;
-  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
-      .WillOnce(Invoke([&message](ConnectionMessage* session_message,
-                                  const OnMessageCallback& callback) {
-        EXPECT_EQ(blink::mojom::PresentationMessageType::TEXT,
-                  session_message->type);
-        EXPECT_EQ(message.utf8(), session_message->message.value());
+  EXPECT_CALL(connection_proxy, SendConnectionMessage(_, _))
+      .WillOnce(Invoke([&expected_message](
+          const PresentationConnectionMessage& message_request,
+          const OnMessageCallback& callback) {
+        EXPECT_EQ(message_request, expected_message);
+        callback.Run(true);
       }));
+
   dispatcher_.sendString(url1_, presentation_id_, message, &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendArrayBuffer) {
+  std::vector<uint8_t> data(array_buffer_data(),
+                            array_buffer_data() + array_buffer_.byteLength());
   TestPresentationConnection connection;
   TestPresentationConnectionProxy connection_proxy(&connection);
+  PresentationConnectionMessage expected_message(data);
 
   base::RunLoop run_loop;
-  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
-      .WillOnce(Invoke([this](ConnectionMessage* message_request,
-                              const OnMessageCallback& callback) {
-        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());
+  EXPECT_CALL(connection_proxy, SendConnectionMessage(_, _))
+      .WillOnce(Invoke([&expected_message](
+          const PresentationConnectionMessage& message_request,
+          const OnMessageCallback& callback) {
+        EXPECT_EQ(message_request, expected_message);
+        callback.Run(true);
       }));
   dispatcher_.sendArrayBuffer(url1_, presentation_id_, array_buffer_data(),
                               array_buffer_.byteLength(), &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendBlobData) {
+  std::vector<uint8_t> data(array_buffer_data(),
+                            array_buffer_data() + array_buffer_.byteLength());
   TestPresentationConnection connection;
   TestPresentationConnectionProxy connection_proxy(&connection);
+  PresentationConnectionMessage expected_message(data);
 
   base::RunLoop run_loop;
-  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
-      .WillOnce(Invoke([this](ConnectionMessage* message_request,
-                              const OnMessageCallback& callback) {
-        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());
+  EXPECT_CALL(connection_proxy, SendConnectionMessage(_, _))
+      .WillOnce(Invoke([&expected_message](
+          const PresentationConnectionMessage& message_request,
+          const OnMessageCallback& callback) {
+        EXPECT_EQ(message_request, expected_message);
         callback.Run(true);
       }));
   dispatcher_.sendBlobData(url1_, presentation_id_, array_buffer_data(),
                            array_buffer_.byteLength(), &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestOnReceiverConnectionAvailable) {
   PresentationSessionInfo session_info(gurl1_, presentation_id_.utf8());
 
@@ skipping 304 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