Revert of [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 "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;
@@ skipping 75 matching lines @@
       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*,
-                          const OnMessageCallback&));
-};
-
-class TestPresentationReceiver : public blink::WebPresentationReceiver {
- public:
-  blink::WebPresentationConnection* onReceiverConnectionAvailable(
-      const blink::WebPresentationSessionInfo&) override {
-    return &connection_;
-  }
-
-  TestPresentationConnection connection_;
-};
-
 class MockPresentationAvailabilityCallbacks
     : public blink::WebCallbacks<bool, const blink::WebPresentationError&> {
  public:
   MOCK_METHOD1(onSuccess, void(bool value));
   MOCK_METHOD1(onError, void(const blink::WebPresentationError&));
 };
 
 class TestWebPresentationConnectionCallback
     : public WebPresentationConnectionCallbacks {
  public:
-  // Does not take ownership of |connection|.
-  TestWebPresentationConnectionCallback(WebURL url,
-                                        WebString id,
-                                        TestPresentationConnection* connection)
-      : url_(url), id_(id), callback_called_(false), connection_(connection) {}
+  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 connection_;
+    return &connection_;
   }
 
  private:
   const WebURL url_;
   const WebString id_;
   bool callback_called_;
-  TestPresentationConnection* connection_;
+  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 30 matching lines @@
           mojo::MakeRequest(&presentation_service_));
     }
   }
 
   MockPresentationService* mock_presentation_service_;
   std::unique_ptr<mojo::Binding<PresentationService>> mock_binding_;
 };
 
 class PresentationDispatcherTest : public ::testing::Test {
  public:
-  using OnMessageCallback = PresentationConnectionProxy::OnMessageCallback;
-
   enum class URLState { Available, Unavailable, Unsupported, Unknown };
 
   PresentationDispatcherTest()
       : gurl1_(GURL("https://www.example.com/1.html")),
         gurl2_(GURL("https://www.example.com/2.html")),
         gurl3_(GURL("https://www.example.com/3.html")),
         gurl4_(GURL("https://www.example.com/4.html")),
         gurls_({gurl1_, gurl2_, gurl3_, gurl4_}),
         url1_(WebURL(gurl1_)),
         url2_(WebURL(gurl2_)),
@@ skipping 83 matching lines @@
   std::vector<MockPresentationAvailabilityObserver*> mock_observers_;
 
   MockPresentationService presentation_service_;
   TestPresentationDispatcher dispatcher_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(PresentationDispatcherTest, TestStartSession) {
-  TestPresentationConnection connection;
-  EXPECT_FALSE(connection.proxy());
-  {
-    base::RunLoop run_loop;
-    EXPECT_CALL(presentation_service_, ListenForConnectionMessages(_));
-    EXPECT_CALL(presentation_service_, SetPresentationConnection(_, _));
-    EXPECT_CALL(presentation_service_, StartSession(gurls_, _))
-        .WillOnce(Invoke([this](
-            const std::vector<GURL>& presentation_urls,
-            const PresentationService::StartSessionCallback& callback) {
-          PresentationSessionInfo session_info(gurl1_, presentation_id_.utf8());
-          callback.Run(session_info, base::nullopt);
-        }));
+  base::RunLoop run_loop;
 
-    dispatcher_.startSession(
-        urls_, base::MakeUnique<TestWebPresentationConnectionCallback>(
-                   url1_, presentation_id_, &connection));
-    run_loop.RunUntilIdle();
-  }
-  EXPECT_TRUE(connection.proxy());
+  EXPECT_CALL(presentation_service_, StartSession(gurls_, _))
+      .WillOnce(Invoke([this](
+          const std::vector<GURL>& presentation_urls,
+          const PresentationService::StartSessionCallback& callback) {
+        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) {
         callback.Run(
             base::nullopt,
             PresentationError(content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
                               error_message.utf8()));
       }));
-  dispatcher_.startSession(
+  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;
 
@@ skipping 10 matching lines @@
                               error_message.utf8()));
       }));
   dispatcher_.joinSession(
       urls_, presentation_id_,
       base::MakeUnique<TestWebPresentationConnectionErrorCallback>(
           WebPresentationError::ErrorTypeNoAvailableScreens, error_message));
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestJoinSession) {
-  TestPresentationConnection connection;
-  EXPECT_FALSE(connection.proxy());
-  {
-    base::RunLoop run_loop;
-    EXPECT_CALL(presentation_service_, ListenForConnectionMessages(_));
-    EXPECT_CALL(presentation_service_, SetPresentationConnection(_, _));
-    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());
-          callback.Run(PresentationSessionInfo(gurl1_, presentation_id_.utf8()),
-                       base::nullopt);
-        }));
+  base::RunLoop run_loop;
 
-    dispatcher_.joinSession(
-        urls_, presentation_id_,
-        base::MakeUnique<TestWebPresentationConnectionCallback>(
-            url1_, presentation_id_, &connection));
-    run_loop.RunUntilIdle();
-  }
-  EXPECT_TRUE(connection.proxy());
+  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());
+        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");
-  TestPresentationConnection connection;
-  TestPresentationConnectionProxy connection_proxy(&connection);
-
   base::RunLoop run_loop;
-  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());
+  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
+      .WillOnce(Invoke([this, &message](
+          const PresentationSessionInfo& session_info,
+          ConnectionMessage* message_request,
+          const PresentationService::SendConnectionMessageCallback& callback) {
+        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, &connection_proxy);
+  dispatcher_.sendString(url1_, presentation_id_, message, nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendArrayBuffer) {
-  TestPresentationConnection connection;
-  TestPresentationConnectionProxy connection_proxy(&connection);
-
   base::RunLoop run_loop;
-  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
-      .WillOnce(Invoke([this](ConnectionMessage* message_request,
-                              const OnMessageCallback& callback) {
+  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
+      .WillOnce(Invoke([this](
+          const PresentationSessionInfo& session_info,
+          ConnectionMessage* message_request,
+          const PresentationService::SendConnectionMessageCallback& callback) {
+        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(), &connection_proxy);
+                              array_buffer_.byteLength(), nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendBlobData) {
-  TestPresentationConnection connection;
-  TestPresentationConnectionProxy connection_proxy(&connection);
-
   base::RunLoop run_loop;
-  EXPECT_CALL(connection_proxy, SendConnectionMessageInternal(_, _))
-      .WillOnce(Invoke([this](ConnectionMessage* message_request,
-                              const OnMessageCallback& callback) {
+  EXPECT_CALL(presentation_service_, SendConnectionMessageInternal(_, _, _))
+      .WillOnce(Invoke([this](
+          const PresentationSessionInfo& session_info,
+          ConnectionMessage* message_request,
+          const PresentationService::SendConnectionMessageCallback& callback) {
+        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(), &connection_proxy);
+                           array_buffer_.byteLength(), nullptr);
   run_loop.RunUntilIdle();
 }
 
-TEST_F(PresentationDispatcherTest, TestOnReceiverConnectionAvailable) {
-  PresentationSessionInfo session_info(gurl1_, presentation_id_.utf8());
-
-  blink::mojom::PresentationConnectionPtr controller_connection_ptr;
-  TestPresentationConnection controller_connection;
-  TestPresentationConnectionProxy controller_connection_proxy(
-      &controller_connection);
-  mojo::Binding<blink::mojom::PresentationConnection> binding(
-      &controller_connection_proxy,
-      mojo::MakeRequest(&controller_connection_ptr));
-
-  blink::mojom::PresentationConnectionPtr receiver_connection_ptr;
-
-  TestPresentationReceiver receiver;
-  dispatcher_.setReceiver(&receiver);
-
-  base::RunLoop run_loop;
-  EXPECT_CALL(controller_connection,
-              didChangeState(blink::WebPresentationConnectionState::Connected));
-  EXPECT_CALL(receiver.connection_,
-              didChangeState(blink::WebPresentationConnectionState::Connected));
-
-  dispatcher_.OnReceiverConnectionAvailable(
-      std::move(session_info), std::move(controller_connection_ptr),
-      mojo::MakeRequest(&receiver_connection_ptr));
-
-  EXPECT_TRUE(receiver_connection_ptr);
-  EXPECT_TRUE(receiver.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;
@@ skipping 266 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