[Presentation API] (5th) (1-UA) integrate controller and receiver side for 1-UA messaging

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"
 #include "content/renderer/presentation/presentation_dispatcher.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/WebPresentationSessionInfo.h"
 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
 
@@ skipping 85 matching lines @@
     ListenForConnectionMessagesInternal(session_info.get());
   }
   MOCK_METHOD1(ListenForConnectionMessagesInternal,
                void(PresentationSessionInfo* session_info));
 
   void SetPresentationConnection(
       blink::mojom::PresentationSessionInfoPtr session,
       blink::mojom::PresentationConnectionPtr controller_conn_ptr,
       blink::mojom::PresentationConnectionRequest receiver_conn_request)
       override {
-    SetPresentationConnection(session.get(), controller_conn_ptr.get());
+    SetPresentationConnectionInternal(session.get(), controller_conn_ptr.get());
   }
-  MOCK_METHOD2(SetPresentationConnection,
+  MOCK_METHOD2(SetPresentationConnectionInternal,
                void(PresentationSessionInfo* session_info,
                     PresentationConnection* connection));
 };
 
+class TestPresentationConnection : public blink::WebPresentationConnection {
+ public:
+  void setProxy(
+      std::unique_ptr<blink::WebPresentationConnectionProxy> proxy) override {
+    proxy_ = std::move(proxy);
+  }
+  MOCK_METHOD1(didReceiveTextMessage, void(const WebString& message));
+  MOCK_METHOD2(didReceiveBinaryMessage,
+               void(const uint8_t* data, size_t length));
+  MOCK_METHOD1(didChangeState, void(blink::WebPresentationConnectionState));
+
+  std::unique_ptr<blink::WebPresentationConnectionProxy> proxy_;
+};
+
+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*,
+                          const OnMessageCallback&));
+};
+
 class TestWebPresentationConnectionCallback
     : public WebPresentationConnectionCallbacks {
  public:
   TestWebPresentationConnectionCallback(WebURL url, WebString id)
       : url_(url), id_(id), callback_called_(false) {}
   ~TestWebPresentationConnectionCallback() override {
     EXPECT_TRUE(callback_called_);
   }
 
   void onSuccess(const WebPresentationSessionInfo& info) override {
     callback_called_ = true;
     EXPECT_EQ(info.url, url_);
     EXPECT_EQ(info.id, id_);
   }
 
-  blink::WebPresentationConnection* getConnection() override { return nullptr; }
+  blink::WebPresentationConnection* getConnection() override {
+    return &connection_;
+  }
 
  private:
   const WebURL url_;
   const WebString id_;
   bool callback_called_;
+  TestPresentationConnection connection_;
 };
 
 class TestWebPresentationConnectionErrorCallback
     : public WebPresentationConnectionCallbacks {
  public:
   TestWebPresentationConnectionErrorCallback(
       WebPresentationError::ErrorType error_type,
       WebString message)
       : error_type_(error_type), message_(message), callback_called_(false) {}
   ~TestWebPresentationConnectionErrorCallback() override {
@@ skipping 69 matching lines @@
   const WebString presentation_id_;
   const WebArrayBuffer array_buffer_;
   MockPresentationAvailabilityObserver observer_;
   MockPresentationService presentation_service_;
   TestPresentationDispatcher dispatcher_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(PresentationDispatcherTest, TestStartSession) {

[mark a. foltz, 2017/01/23 22:29:34]

Are there expectations covering that the proxies are bound to connections on
StartSession and onDefaultSessionStarted?

[zhaobin, 2017/01/24 19:28:46]

Done.

   base::RunLoop run_loop;
 
+  EXPECT_CALL(presentation_service_, ListenForConnectionMessagesInternal(_));
+  EXPECT_CALL(presentation_service_, SetPresentationConnectionInternal(_, _));
   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());
       }));
   dispatcher_.startSession(
@@ skipping 41 matching lines @@
   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_, ListenForConnectionMessagesInternal(_));
+  EXPECT_CALL(presentation_service_, SetPresentationConnectionInternal(_, _));
   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());
       }));
   dispatcher_.joinSession(
       urls_, presentation_id_,
       base::MakeUnique<TestWebPresentationConnectionCallback>(
           url1_, presentation_id_));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendString) {
   WebString message = WebString::fromUTF8("test message");
+  TestPresentationConnection connection;
+  TestPresentationConnectionProxy connection_proxy(&connection);
+
   base::RunLoop run_loop;
-  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
-      .WillOnce(Invoke([this, &message](
-          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_TRUE(message_request->message.has_value());
-        EXPECT_EQ(message.utf8(), message_request->message.value());
-        callback.Run(true);
+  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
+      .WillOnce(Invoke([this, &message](ConnectionMessage* session_message,
+                                        const OnMessageCallback& callback) {
+        EXPECT_EQ(blink::mojom::PresentationMessageType::TEXT,
+                  session_message->type);
+        EXPECT_EQ(message.utf8(), session_message->message.value());
       }));
-  dispatcher_.sendString(url1_, presentation_id_, message, nullptr);
+  dispatcher_.sendString(url1_, presentation_id_, message, &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendArrayBuffer) {
+  TestPresentationConnection connection;
+  TestPresentationConnectionProxy connection_proxy(&connection);
+
   base::RunLoop run_loop;
-  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
-      .WillOnce(Invoke([this](
-          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_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());
-        callback.Run(true);
       }));
   dispatcher_.sendArrayBuffer(url1_, presentation_id_, array_buffer_data(),
-                              array_buffer_.byteLength(), nullptr);
+                              array_buffer_.byteLength(), &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendBlobData) {

[mark a. foltz, 2017/01/23 22:29:34]

Does there need to be a test case added for OnReceiverConnectionAvailable
(proxies are created and bound to connections)?

[zhaobin, 2017/01/24 19:28:46]

Done.

+  TestPresentationConnection connection;
+  TestPresentationConnectionProxy connection_proxy(&connection);
+
   base::RunLoop run_loop;
-  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
-      .WillOnce(Invoke([this](
-          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_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());
         callback.Run(true);
       }));
   dispatcher_.sendBlobData(url1_, presentation_id_, array_buffer_data(),
-                           array_buffer_.byteLength(), nullptr);
+                           array_buffer_.byteLength(), &connection_proxy);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestCloseSession) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_,
               CloseConnection(gurl1_, presentation_id_.utf8()));
   dispatcher_.closeSession(url1_, presentation_id_);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestTerminateSession) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_,
               Terminate(gurl1_, presentation_id_.utf8()));
   dispatcher_.terminateSession(url1_, presentation_id_);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestListenForScreenAvailability) {
   base::RunLoop run_loop1;
   EXPECT_CALL(presentation_service_, ListenForScreenAvailability(gurl1_));
   dispatcher_.getAvailability(
       url1_, base::MakeUnique<WebPresentationAvailabilityCallbacks>());
   dispatcher_.OnScreenAvailabilityUpdated(url1_, true);
+  EXPECT_CALL(presentation_service_,
+              StopListeningForScreenAvailability(gurl1_));
   run_loop1.RunUntilIdle();
 
   base::RunLoop run_loop2;
   EXPECT_CALL(presentation_service_, ListenForScreenAvailability(gurl1_));
   dispatcher_.startListening(&observer_);
   run_loop2.RunUntilIdle();
 
   base::RunLoop run_loop3;
   EXPECT_CALL(observer_, availabilityChanged(false));
   dispatcher_.OnScreenAvailabilityUpdated(url1_, false);
@@ skipping 12 matching lines @@
 }
 
 TEST_F(PresentationDispatcherTest, TestSetDefaultPresentationUrls) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_, SetDefaultPresentationUrls(gurls_));
   dispatcher_.setDefaultPresentationUrls(urls_);
   run_loop.RunUntilIdle();
 }
 
 }  // namespace content