[OnionSoup] Move persentation_service.mojom from //content to //third_party/WebKit

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 mojom::SessionMessage* expected,
-                                         const mojom::SessionMessage* actual) {
+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(mojom::PresentationSessionInfoPtr info,
-               mojom::PresentationErrorPtr error) {}
+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,
            PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD2(RemoveObserver,
@@ skipping 72 matching lines @@
                         state_changed_cb));
 
   void set_screen_availability_listening_supported(bool value) {
     screen_availability_listening_supported_ = value;
   }
 
  private:
   bool screen_availability_listening_supported_ = true;
 };
 
-class MockPresentationServiceClient : public mojom::PresentationServiceClient {
+class MockPresentationServiceClient
+    : public blink::mojom::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
       void(const mojo::String& url, bool available));
   void OnConnectionStateChanged(
-      mojom::PresentationSessionInfoPtr connection,
-      mojom::PresentationConnectionState new_state) override {
+      blink::mojom::PresentationSessionInfoPtr connection,
+      blink::mojom::PresentationConnectionState new_state) override {
     OnConnectionStateChanged(*connection, new_state);
   }
   MOCK_METHOD2(OnConnectionStateChanged,
-               void(const mojom::PresentationSessionInfo& connection,
-                    mojom::PresentationConnectionState new_state));
+               void(const blink::mojom::PresentationSessionInfo& connection,
+                    blink::mojom::PresentationConnectionState new_state));
 
-  void OnConnectionClosed(mojom::PresentationSessionInfoPtr connection,
-                          mojom::PresentationConnectionCloseReason reason,
-                          const mojo::String& message) override {
+  void OnConnectionClosed(
+      blink::mojom::PresentationSessionInfoPtr connection,
+      blink::mojom::PresentationConnectionCloseReason reason,
+      const mojo::String& message) override {
     OnConnectionClosed(*connection, reason, message);
   }
   MOCK_METHOD3(OnConnectionClosed,
-               void(const mojom::PresentationSessionInfo& connection,
-                    mojom::PresentationConnectionCloseReason reason,
+               void(const blink::mojom::PresentationSessionInfo& connection,
+                    blink::mojom::PresentationConnectionCloseReason reason,
                     const mojo::String& message));
 
   MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
 
   void OnSessionMessagesReceived(
-      mojom::PresentationSessionInfoPtr session_info,
-      mojo::Array<mojom::SessionMessagePtr> messages) override {
+      blink::mojom::PresentationSessionInfoPtr session_info,
+      mojo::Array<blink::mojom::SessionMessagePtr> messages) override {
     messages_received_ = std::move(messages);
     MessagesReceived();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
   void OnDefaultSessionStarted(
-      mojom::PresentationSessionInfoPtr session_info) override {
+      blink::mojom::PresentationSessionInfoPtr session_info) override {
     OnDefaultSessionStarted(*session_info);
   }
   MOCK_METHOD1(OnDefaultSessionStarted,
-               void(const mojom::PresentationSessionInfo& session_info));
+               void(const blink::mojom::PresentationSessionInfo& session_info));
 
-  mojo::Array<mojom::SessionMessagePtr> messages_received_;
+  mojo::Array<blink::mojom::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest() {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
     EXPECT_CALL(mock_delegate_, AddObserver(_, _, _)).Times(1);
     TestRenderFrameHost* render_frame_host = contents()->GetMainFrame();
     render_frame_host->InitializeRenderFrameIfNeeded();
     service_impl_.reset(new PresentationServiceImpl(
         render_frame_host, contents(), &mock_delegate_));
     service_impl_->Bind(std::move(request));
 
-    mojom::PresentationServiceClientPtr client_ptr;
-    client_binding_.reset(new mojo::Binding<mojom::PresentationServiceClient>(
-        &mock_client_, mojo::GetProxy(&client_ptr)));
+    blink::mojom::PresentationServiceClientPtr client_ptr;
+    client_binding_.reset(
+        new mojo::Binding<blink::mojom::PresentationServiceClient>(
+            &mock_client_, mojo::GetProxy(&client_ptr)));
     service_impl_->SetClient(std::move(client_ptr));
   }
 
   void TearDown() override {
     service_ptr_.reset();
     if (service_impl_.get()) {
       EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
       service_impl_.reset();
     }
     RenderViewHostImplTestHarness::TearDown();
@@ skipping 49 matching lines @@
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
     EXPECT_EQ(
         service_impl_->screen_availability_listeners_.find(kPresentationUrl),
         service_impl_->screen_availability_listeners_.end());
     EXPECT_FALSE(service_impl_->on_session_messages_callback_.get());
   }
 
   void ExpectNewSessionMojoCallbackSuccess(
-      mojom::PresentationSessionInfoPtr info,
-      mojom::PresentationErrorPtr error) {
+      blink::mojom::PresentationSessionInfoPtr info,
+      blink::mojom::PresentationErrorPtr error) {
     EXPECT_FALSE(info.is_null());
     EXPECT_TRUE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
-  void ExpectNewSessionMojoCallbackError(mojom::PresentationSessionInfoPtr info,
-                                         mojom::PresentationErrorPtr error) {
+  void ExpectNewSessionMojoCallbackError(
+      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<mojom::SessionMessagePtr>& expected_msgs,
-      const mojo::Array<mojom::SessionMessagePtr>& actual_msgs) {
+      const mojo::Array<blink::mojom::SessionMessagePtr>& expected_msgs,
+      const mojo::Array<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()));
     }
   }
 
   void ExpectSendMessageMojoCallback(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<mojom::SessionMessagePtr> expected_msgs(2);
-    expected_msgs[0] = mojom::SessionMessage::New();
-    expected_msgs[0]->type = mojom::PresentationMessageType::TEXT;
+    mojo::Array<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] = mojom::SessionMessage::New();
-    expected_msgs[1]->type = mojom::PresentationMessageType::ARRAY_BUFFER;
+    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);
 
-    mojom::PresentationSessionInfoPtr session(
-        mojom::PresentationSessionInfo::New());
+    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(_, _, _, _))
         .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                         SaveArg<3>(&message_cb)));
     service_ptr_->ListenForSessionMessages(session.Clone());
     run_loop.Run();
     }
 
     ScopedVector<PresentationSessionMessage> messages;
     std::unique_ptr<content::PresentationSessionMessage> message;
     message.reset(
         new content::PresentationSessionMessage(PresentationMessageType::TEXT));
     message->message = text_msg;
     messages.push_back(std::move(message));
     message.reset(new content::PresentationSessionMessage(
         PresentationMessageType::ARRAY_BUFFER));
     message->data.reset(new std::vector<uint8_t>(binary_data));
     messages.push_back(std::move(message));
 
-    std::vector<mojom::SessionMessagePtr> actual_msgs;
+    std::vector<blink::mojom::SessionMessagePtr> actual_msgs;
     {
       base::RunLoop run_loop;
       EXPECT_CALL(mock_client_, MessagesReceived())
           .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
       message_cb.Run(std::move(messages), pass_ownership);
       run_loop.Run();
     }
     ExpectSessionMessages(expected_msgs, mock_client_.messages_received_);
   }
 
   MockPresentationServiceDelegate mock_delegate_;
 
   std::unique_ptr<PresentationServiceImpl> service_impl_;
-  mojo::InterfacePtr<mojom::PresentationService> service_ptr_;
+  mojo::InterfacePtr<blink::mojom::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
-  std::unique_ptr<mojo::Binding<mojom::PresentationServiceClient>>
+  std::unique_ptr<mojo::Binding<blink::mojom::PresentationServiceClient>>
       client_binding_;
 
   base::Closure run_loop_quit_closure_;
 };
 
 TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
   ListenForScreenAvailabilityAndWait(kPresentationUrl, true);
 
   SimulateScreenAvailabilityChangeAndWait(kPresentationUrl, true);
   SimulateScreenAvailabilityChangeAndWait(kPresentationUrl, false);
@@ skipping 70 matching lines @@
   EXPECT_EQ(url1, service_impl_->default_presentation_url_);
 
   std::string url2("http://barUrl");
   // Sets different DPU.
   content::PresentationSessionStartedCallback callback;
   EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url2), _))
       .WillOnce(SaveArg<3>(&callback));
   service_impl_->SetDefaultPresentationURL(url2);
   EXPECT_EQ(url2, service_impl_->default_presentation_url_);
 
-  mojom::PresentationSessionInfo session_info;
+  blink::mojom::PresentationSessionInfo session_info;
   session_info.url = url2;
   session_info.id = kPresentationId;
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_, OnDefaultSessionStarted(Equals(session_info)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   callback.Run(content::PresentationSessionInfo(url2, kPresentationId));
   run_loop.Run();
 }
 
 TEST_F(PresentationServiceImplTest, ListenForConnectionStateChange) {
   content::PresentationSessionInfo connection(kPresentationUrl,
                                               kPresentationId);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
   service_impl_->ListenForConnectionStateChange(connection);
 
   // Trigger state change. It should be propagated back up to |mock_client_|.
-  mojom::PresentationSessionInfo presentation_connection;
+  blink::mojom::PresentationSessionInfo presentation_connection;
   presentation_connection.url = kPresentationUrl;
   presentation_connection.id = kPresentationId;
   {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_client_,
                 OnConnectionStateChanged(
                     Equals(presentation_connection),
-                    mojom::PresentationConnectionState::TERMINATED))
+                    blink::mojom::PresentationConnectionState::TERMINATED))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(PresentationConnectionStateChangeInfo(
         PRESENTATION_CONNECTION_STATE_TERMINATED));
     run_loop.Run();
   }
 }
 
 TEST_F(PresentationServiceImplTest, ListenForConnectionClose) {
   content::PresentationSessionInfo connection(kPresentationUrl,
                                               kPresentationId);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
   service_impl_->ListenForConnectionStateChange(connection);
 
   // Trigger connection close. It should be propagated back up to
   // |mock_client_|.
-  mojom::PresentationSessionInfo presentation_connection;
+  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),
-                           mojom::PresentationConnectionCloseReason::WENT_AWAY,
-                           mojo::String("Foo")))
+    EXPECT_CALL(mock_client_,
+                OnConnectionClosed(
+                    Equals(presentation_connection),
+                    blink::mojom::PresentationConnectionCloseReason::WENT_AWAY,
+                    mojo::String("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 133 matching lines @@
       presentation_url2,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
           base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendStringMessage) {
   std::string message("Test presentation session message");
 
-  mojom::PresentationSessionInfoPtr session(
-      mojom::PresentationSessionInfo::New());
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
-  mojom::SessionMessagePtr message_request(mojom::SessionMessage::New());
-  message_request->type = mojom::PresentationMessageType::TEXT;
+  blink::mojom::SessionMessagePtr message_request(
+      blink::mojom::SessionMessage::New());
+  message_request->type = blink::mojom::PresentationMessageType::TEXT;
   message_request->message = message;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
@@ skipping 11 matching lines @@
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
   // Test Array buffer data.
   const uint8_t buffer[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
-  mojom::PresentationSessionInfoPtr session(
-      mojom::PresentationSessionInfo::New());
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
-  mojom::SessionMessagePtr message_request(mojom::SessionMessage::New());
-  message_request->type = mojom::PresentationMessageType::ARRAY_BUFFER;
+  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);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
@@ skipping 17 matching lines @@
 
 TEST_F(PresentationServiceImplTest, SendArrayBufferWithExceedingLimit) {
   // Create buffer with size exceeding the limit.
   // Use same size as in content::kMaxPresentationSessionMessageSize.
   const size_t kMaxBufferSizeInBytes = 64 * 1024;  // 64 KB.
   uint8_t buffer[kMaxBufferSizeInBytes + 1];
   memset(buffer, 0, kMaxBufferSizeInBytes+1);
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
-  mojom::PresentationSessionInfoPtr session(
-      mojom::PresentationSessionInfo::New());
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
-  mojom::SessionMessagePtr message_request(mojom::SessionMessage::New());
-  message_request->type = mojom::PresentationMessageType::ARRAY_BUFFER;
+  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);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  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),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   EXPECT_FALSE(test_message);
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendBlobData) {
   const uint8_t buffer[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
-  mojom::PresentationSessionInfoPtr session(
-      mojom::PresentationSessionInfo::New());
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
-  mojom::SessionMessagePtr message_request(mojom::SessionMessage::New());
-  message_request->type = mojom::PresentationMessageType::BLOB;
+  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);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
@@ skipping 43 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