[Presentation API] Convert presentation.mojom to new wrapper types.

content/browser/presentation/presentation_service_impl_unittest.cc

 // 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.
 
 #include "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 28 matching lines @@
 namespace {
 
 // Matches mojo structs.
 MATCHER_P(Equals, expected, "") {
   return expected.Equals(arg);
 }
 
 const char *const kPresentationId = "presentationId";
 const char *const kPresentationUrl = "http://foo.com/index.html";
 
-bool ArePresentationSessionMessagesEqual(
-    const blink::mojom::SessionMessage* expected,
-    const blink::mojom::SessionMessage* actual) {
-  return expected->type == actual->type &&
-         expected->message == actual->message &&
-         expected->data.Equals(actual->data);
-}
-
 void DoNothing(blink::mojom::PresentationSessionInfoPtr info,
                blink::mojom::PresentationErrorPtr error) {}
 
 }  // namespace
 
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
   MOCK_METHOD3(AddObserver,
       void(int render_process_id,
            int render_frame_id,
@@ skipping 78 matching lines @@
   }
 
  private:
   bool screen_availability_listening_supported_ = true;
 };
 
 class MockPresentationServiceClient
     : public blink::mojom::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
-      void(const mojo::String& url, bool available));
+               void(const std::string& url, bool available));
   void OnConnectionStateChanged(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionState new_state) override {
     OnConnectionStateChanged(*connection, new_state);
   }
   MOCK_METHOD2(OnConnectionStateChanged,
                void(const blink::mojom::PresentationSessionInfo& connection,
                     blink::mojom::PresentationConnectionState new_state));
 
   void OnConnectionClosed(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionCloseReason reason,
-      const mojo::String& message) override {
+      const std::string& message) override {
     OnConnectionClosed(*connection, reason, message);
   }
   MOCK_METHOD3(OnConnectionClosed,
                void(const blink::mojom::PresentationSessionInfo& connection,
                     blink::mojom::PresentationConnectionCloseReason reason,
-                    const mojo::String& message));
+                    const std::string& message));
 
-  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
+  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const std::string& url));
 
   void OnSessionMessagesReceived(
       blink::mojom::PresentationSessionInfoPtr session_info,
-      mojo::Array<blink::mojom::SessionMessagePtr> messages) override {
+      std::vector<blink::mojom::SessionMessagePtr> messages) override {
     messages_received_ = std::move(messages);
     MessagesReceived();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
   void OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfoPtr session_info) override {
     OnDefaultSessionStarted(*session_info);
   }
   MOCK_METHOD1(OnDefaultSessionStarted,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
-  mojo::Array<blink::mojom::SessionMessagePtr> messages_received_;
+  std::vector<blink::mojom::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest() {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
@@ skipping 13 matching lines @@
 
   void TearDown() override {
     service_ptr_.reset();
     if (service_impl_.get()) {
       EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
       service_impl_.reset();
     }
     RenderViewHostImplTestHarness::TearDown();
   }
 
-  void ListenForScreenAvailabilityAndWait(
-      const mojo::String& url, bool delegate_success) {
+  void ListenForScreenAvailabilityAndWait(const std::string& url,
+                                          bool delegate_success) {
     base::RunLoop run_loop;
     // This will call to |service_impl_| via mojo. Process the message
     // using RunLoop.
     // The callback shouldn't be invoked since there is no availability
     // result yet.
     EXPECT_CALL(mock_delegate_, AddScreenAvailabilityListener())
         .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             Return(delegate_success)));
     service_ptr_->ListenForScreenAvailability(url);
@@ skipping 15 matching lines @@
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
 
   void SimulateScreenAvailabilityChangeAndWait(
       const std::string& url, bool available) {
     auto listener_it = service_impl_->screen_availability_listeners_.find(url);
     ASSERT_TRUE(listener_it->second);
 
     base::RunLoop run_loop;
-    EXPECT_CALL(mock_client_,
-                OnScreenAvailabilityUpdated(mojo::String(url), available))
-      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+    EXPECT_CALL(mock_client_, OnScreenAvailabilityUpdated(url, available))
+        .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     listener_it->second->OnScreenAvailabilityChanged(available);
     run_loop.Run();
   }
 
   void ExpectReset() {
     EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
@@ skipping 15 matching lines @@
   void ExpectNewSessionCallbackError(
       blink::mojom::PresentationSessionInfoPtr info,
       blink::mojom::PresentationErrorPtr error) {
     EXPECT_TRUE(info.is_null());
     EXPECT_FALSE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   void ExpectSessionMessages(
-      const mojo::Array<blink::mojom::SessionMessagePtr>& expected_msgs,
-      const mojo::Array<blink::mojom::SessionMessagePtr>& actual_msgs) {
+      const std::vector<blink::mojom::SessionMessagePtr>& expected_msgs,
+      const std::vector<blink::mojom::SessionMessagePtr>& actual_msgs) {
     EXPECT_EQ(expected_msgs.size(), actual_msgs.size());
-    for (size_t i = 0; i < actual_msgs.size(); ++i) {
-      EXPECT_TRUE(ArePresentationSessionMessagesEqual(expected_msgs[i].get(),
-                                                      actual_msgs[i].get()));
-    }
+    for (size_t i = 0; i < actual_msgs.size(); ++i)
+      EXPECT_TRUE(expected_msgs[i].Equals(actual_msgs[i]));
   }
 
   void ExpectSendSessionMessageCallback(bool success) {
     EXPECT_TRUE(success);
     EXPECT_FALSE(service_impl_->send_message_callback_);
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   void RunListenForSessionMessages(const std::string& text_msg,
                                    const std::vector<uint8_t>& binary_data,
                                    bool pass_ownership) {
-    mojo::Array<blink::mojom::SessionMessagePtr> expected_msgs(2);
+    std::vector<blink::mojom::SessionMessagePtr> expected_msgs(2);
     expected_msgs[0] = blink::mojom::SessionMessage::New();
     expected_msgs[0]->type = blink::mojom::PresentationMessageType::TEXT;
     expected_msgs[0]->message = text_msg;
     expected_msgs[1] = blink::mojom::SessionMessage::New();
     expected_msgs[1]->type =
         blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-    expected_msgs[1]->data = mojo::Array<uint8_t>::From(binary_data);
+    expected_msgs[1]->data = binary_data;
 
     blink::mojom::PresentationSessionInfoPtr session(
         blink::mojom::PresentationSessionInfo::New());
     session->url = kPresentationUrl;
     session->id = kPresentationId;
 
     PresentationSessionMessageCallback message_cb;
     {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _))
@@ skipping 170 matching lines @@
   blink::mojom::PresentationSessionInfo presentation_connection;
   presentation_connection.url = kPresentationUrl;
   presentation_connection.id = kPresentationId;
   {
     base::RunLoop run_loop;
     PresentationConnectionStateChangeInfo closed_info(
         PRESENTATION_CONNECTION_STATE_CLOSED);
     closed_info.close_reason = PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
     closed_info.message = "Foo";
 
-    EXPECT_CALL(mock_client_,
-                OnConnectionClosed(
-                    Equals(presentation_connection),
-                    blink::mojom::PresentationConnectionCloseReason::WENT_AWAY,
-                    mojo::String("Foo")))
+    EXPECT_CALL(
+        mock_client_,
+        OnConnectionClosed(
+            Equals(presentation_connection),
+            blink::mojom::PresentationConnectionCloseReason::WENT_AWAY, "Foo"))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(closed_info);
     run_loop.Run();
   }
 }
 
 TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrl) {
   EXPECT_CALL(mock_delegate_,
               SetDefaultPresentationUrl(_, _, Eq(kPresentationUrl), _))
       .Times(1);
@@ skipping 39 matching lines @@
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<4>(&error_cb)));
   run_loop.Run();
   error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, JoinSessionSuccess) {
   service_ptr_->JoinSession(
-      kPresentationUrl,
-      kPresentationId,
-      base::Bind(
-          &PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
-          base::Unretained(this)));
+      kPresentationUrl, base::Optional<std::string>(kPresentationId),
+      base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
+                 base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
   EXPECT_CALL(mock_delegate_, JoinSession(
       _, _, Eq(kPresentationUrl), Eq(kPresentationId), _, _))
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<4>(&success_cb)));
   run_loop.Run();
 
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .Times(1);
   success_cb.Run(PresentationSessionInfo(kPresentationUrl, kPresentationId));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, JoinSessionError) {
   service_ptr_->JoinSession(
-      kPresentationUrl,
-      kPresentationId,
-      base::Bind(
-          &PresentationServiceImplTest::ExpectNewSessionCallbackError,
-          base::Unretained(this)));
+      kPresentationUrl, base::Optional<std::string>(kPresentationId),
+      base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
+                 base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationError&)> error_cb;
   EXPECT_CALL(mock_delegate_, JoinSession(
       _, _, Eq(kPresentationUrl), Eq(kPresentationId), _, _))
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<5>(&error_cb)));
   run_loop.Run();
   error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
   SaveQuitClosureAndRunLoop();
@@ skipping 92 matching lines @@
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-  message_request->data = mojo::Array<uint8_t>::From(data);
+  message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
@@ skipping 23 matching lines @@
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-  message_request->data = mojo::Array<uint8_t>::From(data);
+  message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
@@ skipping 10 matching lines @@
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::BLOB;
-  message_request->data = mojo::Array<uint8_t>::From(data);
+  message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
@@ skipping 42 matching lines @@
   mock_delegate_.set_screen_availability_listening_supported(false);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
   run_loop.Run();
 }
 
 }  // namespace content