[Presentation API] Remove references to presentation sessions.

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/WebPresentationInfo.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::WebPresentationInfo;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 using blink::mojom::PresentationConnection;
 using blink::mojom::PresentationService;
 using blink::mojom::PresentationServiceClientPtr;
 
 // TODO(crbug.com/576808): Add test cases for the following:
 // - State changes
 // - Messages received
@@ skipping 18 matching lines @@
 };
 
 class MockPresentationService : public PresentationService {
  public:
   void SetClient(PresentationServiceClientPtr client) override {}
   MOCK_METHOD1(SetDefaultPresentationUrls,
                void(const std::vector<GURL>& presentation_urls));
   MOCK_METHOD1(ListenForScreenAvailability, void(const GURL& availability_url));
   MOCK_METHOD1(StopListeningForScreenAvailability,
                void(const GURL& availability_url));
-  MOCK_METHOD2(StartSession,
+  MOCK_METHOD2(StartPresentation,
                void(const std::vector<GURL>& presentation_urls,
-                    const StartSessionCallback& callback));
-  MOCK_METHOD3(JoinSession,
+                    const StartPresentationCallback& callback));
+  MOCK_METHOD3(ReconnectPresentation,
                void(const std::vector<GURL>& presentation_urls,
                     const base::Optional<std::string>& presentation_id,
-                    const JoinSessionCallback& callback));
+                    const ReconnectPresentationCallback& callback));
+  void SetPresentationConnection(
+      const PresentationInfo& presentation_info,
+      blink::mojom::PresentationConnectionPtr controller_conn_ptr,
+      blink::mojom::PresentationConnectionRequest receiver_conn_request)
+      override {
+    SetPresentationConnection(presentation_info, controller_conn_ptr.get());
+  }
+  MOCK_METHOD2(SetPresentationConnection,
+               void(const PresentationInfo& presentation_info,
+                    PresentationConnection* connection));
   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));
+               void(const PresentationInfo& presentation_info));
 };
 
 class TestPresentationConnectionProxy : public PresentationConnectionProxy {
  public:
   TestPresentationConnectionProxy(blink::WebPresentationConnection* connection)
       : PresentationConnectionProxy(connection) {}
 
   // PresentationConnectionMessage is move-only.
   void SendConnectionMessage(PresentationConnectionMessage message,
                              const OnMessageCallback& cb) const {
     SendConnectionMessageInternal(message, cb);
   }
   MOCK_CONST_METHOD2(SendConnectionMessageInternal,
                      void(const PresentationConnectionMessage&,
                           const OnMessageCallback&));
   MOCK_CONST_METHOD0(close, void());
 };
 
 class TestPresentationReceiver : public blink::WebPresentationReceiver {
  public:
   blink::WebPresentationConnection* onReceiverConnectionAvailable(
-      const blink::WebPresentationSessionInfo&) override {
+      const blink::WebPresentationInfo&) override {
     return &connection_;
   }
 
-  MOCK_METHOD1(didChangeSessionState,
+  MOCK_METHOD1(didChangeConnectionState,
                void(blink::WebPresentationConnectionState));
   MOCK_METHOD0(terminateConnection, void());
 
   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() override {
     EXPECT_TRUE(callback_called_);
   }
 
-  void onSuccess(const WebPresentationSessionInfo& info) override {
+  void onSuccess(const WebPresentationInfo& info) override {
     callback_called_ = true;
     EXPECT_EQ(info.url, url_);
     EXPECT_EQ(info.id, id_);
   }
 
   blink::WebPresentationConnection* getConnection() override {
     return connection_;
   }
 
  private:
@@ skipping 148 matching lines @@
   MockPresentationAvailabilityObserver mock_observer3_;
   std::vector<MockPresentationAvailabilityObserver*> mock_observers_;
 
   MockPresentationService presentation_service_;
   TestPresentationDispatcher dispatcher_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
-TEST_F(PresentationDispatcherTest, TestStartSession) {
+TEST_F(PresentationDispatcherTest, TestStartPresentation) {
   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);
-        }));
+    EXPECT_CALL(presentation_service_, StartPresentation(gurls_, _))
+        .WillOnce(
+            Invoke([this](const std::vector<GURL>& presentation_urls,
+                          const PresentationService::StartPresentationCallback&
+                              callback) {
+              PresentationInfo presentation_info(gurl1_,
+                                                 presentation_id_.utf8());
+              callback.Run(presentation_info, base::nullopt);
+            }));
 
-    dispatcher_.startSession(
+    dispatcher_.startPresentation(
         urls_, base::MakeUnique<TestWebPresentationConnectionCallback>(
                    url1_, presentation_id_, &connection));
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(connection.proxy());
 }
 
-TEST_F(PresentationDispatcherTest, TestStartSessionError) {
+TEST_F(PresentationDispatcherTest, TestStartPresentationError) {
   WebString error_message = WebString::fromUTF8("Test error message");
   base::RunLoop run_loop;
 
-  EXPECT_CALL(presentation_service_, StartSession(gurls_, _))
+  EXPECT_CALL(presentation_service_, StartPresentation(gurls_, _))
       .WillOnce(Invoke([&error_message](
-          const std::vector<GURL>& presentation_urls,
-          const PresentationService::StartSessionCallback& callback) {
+                           const std::vector<GURL>& presentation_urls,
+                           const PresentationService::StartPresentationCallback&
+                               callback) {
         callback.Run(
             base::nullopt,
             PresentationError(content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
                               error_message.utf8()));
       }));
-  dispatcher_.startSession(
+  dispatcher_.startPresentation(
       urls_,
       base::MakeUnique<TestWebPresentationConnectionErrorCallback>(
           WebPresentationError::ErrorTypeNoAvailableScreens, error_message));
   run_loop.RunUntilIdle();
 }
 
-TEST_F(PresentationDispatcherTest, TestJoinSessionError) {
+TEST_F(PresentationDispatcherTest, TestReconnectPresentationError) {
   WebString error_message = WebString::fromUTF8("Test error message");
   base::RunLoop run_loop;
 
-  EXPECT_CALL(presentation_service_, JoinSession(gurls_, _, _))
-      .WillOnce(Invoke([this, &error_message](
-          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(
-            base::nullopt,
-            PresentationError(content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
-                              error_message.utf8()));
-      }));
-  dispatcher_.joinSession(
+  EXPECT_CALL(presentation_service_, ReconnectPresentation(gurls_, _, _))
+      .WillOnce(
+          Invoke([this, &error_message](
+                     const std::vector<GURL>& presentation_urls,
+                     const base::Optional<std::string>& presentation_id,
+                     const PresentationService::ReconnectPresentationCallback&
+                         callback) {
+            EXPECT_TRUE(presentation_id.has_value());
+            EXPECT_EQ(presentation_id_.utf8(), presentation_id.value());
+            callback.Run(base::nullopt,
+                         PresentationError(
+                             content::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
+                             error_message.utf8()));
+          }));
+  dispatcher_.reconnectPresentation(
       urls_, presentation_id_,
       base::MakeUnique<TestWebPresentationConnectionErrorCallback>(
           WebPresentationError::ErrorTypeNoAvailableScreens, error_message));
   run_loop.RunUntilIdle();
 }
 
-TEST_F(PresentationDispatcherTest, TestJoinSession) {
+TEST_F(PresentationDispatcherTest, TestReconnectPresentation) {
   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);
-        }));
+    EXPECT_CALL(presentation_service_, ReconnectPresentation(gurls_, _, _))
+        .WillOnce(Invoke(
+            [this](const std::vector<GURL>& presentation_urls,
+                   const base::Optional<std::string>& presentation_id,
+                   const PresentationService::ReconnectPresentationCallback&
+                       callback) {
+              EXPECT_TRUE(presentation_id.has_value());
+              EXPECT_EQ(presentation_id_.utf8(), presentation_id.value());
+              callback.Run(PresentationInfo(gurl1_, presentation_id_.utf8()),
+                           base::nullopt);
+            }));
 
-    dispatcher_.joinSession(
+    dispatcher_.reconnectPresentation(
         urls_, presentation_id_,
         base::MakeUnique<TestWebPresentationConnectionCallback>(
             url1_, presentation_id_, &connection));
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(connection.proxy());
 }
 
 TEST_F(PresentationDispatcherTest, TestSendString) {
   WebString message = WebString::fromUTF8("test message");
@@ skipping 49 matching lines @@
                            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());
+  PresentationInfo presentation_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),
+      std::move(presentation_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) {
+TEST_F(PresentationDispatcherTest, TestCloseConnection) {
   base::RunLoop run_loop;
   TestPresentationConnection connection;
   TestPresentationConnectionProxy test_proxy(&connection);
   EXPECT_CALL(test_proxy, close());
   EXPECT_CALL(presentation_service_,
               CloseConnection(gurl1_, presentation_id_.utf8()));
-  dispatcher_.closeSession(url1_, presentation_id_, &test_proxy);
+  dispatcher_.closeConnection(url1_, presentation_id_, &test_proxy);
   run_loop.RunUntilIdle();
 }
 
-TEST_F(PresentationDispatcherTest, TestTerminateSession) {
+TEST_F(PresentationDispatcherTest, TestTerminatePresentation) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_,
               Terminate(gurl1_, presentation_id_.utf8()));
-  dispatcher_.terminateConnection(url1_, presentation_id_);
+  dispatcher_.terminatePresentation(url1_, presentation_id_);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestListenForScreenAvailability) {
   base::RunLoop run_loop1;
   for (const auto& gurl : gurls_) {
     EXPECT_CALL(presentation_service_, ListenForScreenAvailability(gurl));
     EXPECT_CALL(presentation_service_,
                 StopListeningForScreenAvailability(gurl));
   }
@@ skipping 253 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