[Presentation API] Remove references to presentation sessions.

third_party/WebKit/Source/modules/presentation/PresentationReceiverTest.cpp

 // Copyright 2016 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 "modules/presentation/PresentationReceiver.h"
 
 #include <memory>
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 16 matching lines @@
   MockEventListener() : EventListener(CPPEventListenerType) {}
 
   bool operator==(const EventListener& other) const final {
     return this == &other;
   }
 
   MOCK_METHOD2(handleEvent, void(ExecutionContext* executionContext, Event*));
 };
 
 class MockWebPresentationClient : public WebPresentationClient {
-  void startSession(
+  void startPresentation(
       const WebVector<WebURL>& presentationUrls,
       std::unique_ptr<WebPresentationConnectionCallbacks> callbacks) override {
-    return startSession_(presentationUrls, callbacks);
+    return startPresentation_(presentationUrls, callbacks);
   }
-  void joinSession(
+  void reconnectPresentation(
       const WebVector<WebURL>& presentationUrls,
       const WebString& presentationId,
       std::unique_ptr<WebPresentationConnectionCallbacks> callbacks) override {
-    return joinSession_(presentationUrls, presentationId, callbacks);
+    return reconnectPresentation_(presentationUrls, presentationId, callbacks);
   }
 
   void getAvailability(const WebVector<WebURL>& availabilityURLs,
                        std::unique_ptr<WebPresentationAvailabilityCallbacks>
                            callbacks) override {
     return getAvailability_(availabilityURLs, callbacks);
   }
 
  public:
   MOCK_METHOD1(setController, void(WebPresentationController*));
 
   MOCK_METHOD1(setReceiver, void(WebPresentationReceiver*));
 
-  MOCK_METHOD2(startSession_,
+  MOCK_METHOD2(startPresentation_,
                void(const WebVector<WebURL>& presentationUrls,
                     std::unique_ptr<WebPresentationConnectionCallbacks>&));
 
-  MOCK_METHOD3(joinSession_,
+  MOCK_METHOD3(reconnectPresentation_,
                void(const WebVector<WebURL>& presentationUrls,
                     const WebString& presentationId,
                     std::unique_ptr<WebPresentationConnectionCallbacks>&));
 
   MOCK_METHOD4(sendString,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const WebString& message,
                     const WebPresentationConnectionProxy* proxy));
 
   MOCK_METHOD5(sendArrayBuffer,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const uint8_t* data,
                     size_t length,
                     const WebPresentationConnectionProxy* proxy));
 
   MOCK_METHOD5(sendBlobData,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const uint8_t* data,
                     size_t length,
                     const WebPresentationConnectionProxy* proxy));
 
-  MOCK_METHOD3(closeSession,
+  MOCK_METHOD3(closeConnection,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const WebPresentationConnectionProxy*));
 
-  MOCK_METHOD2(terminateConnection,
+  MOCK_METHOD2(terminatePresentation,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId));
 
   MOCK_METHOD2(getAvailability_,
                void(const WebVector<WebURL>& availabilityUrls,
                     std::unique_ptr<WebPresentationAvailabilityCallbacks>&));
 
   MOCK_METHOD1(startListening, void(WebPresentationAvailabilityObserver*));
 
   MOCK_METHOD1(stopListening, void(WebPresentationAvailabilityObserver*));
@@ skipping 52 matching lines @@
   auto receiver = new PresentationReceiver(&scope.frame(), nullptr);
 
   auto eventHandler = new StrictMock<MockEventListener>();
   addConnectionavailableEventListener(eventHandler, receiver);
   EXPECT_CALL(*eventHandler, handleEvent(testing::_, testing::_)).Times(0);
 
   receiver->connectionList(scope.getScriptState());
 
   // Receive first connection.
   receiver->onReceiverConnectionAvailable(
-      WebPresentationSessionInfo(KURL(KURL(), "http://example.com"), "id"));
+      WebPresentationInfo(KURL(KURL(), "http://example.com"), "id"));
 
   verifyConnectionListPropertyState(ScriptPromisePropertyBase::Resolved,
                                     receiver);
   verifyConnectionListSize(1, receiver);
 }
 
 TEST_F(PresentationReceiverTest, TwoConnectionsFireOnconnectionavailableEvent) {
   V8TestingScope scope;
   auto receiver = new PresentationReceiver(&scope.frame(), nullptr);
 
   StrictMock<MockEventListener>* eventHandler =
       new StrictMock<MockEventListener>();
   addConnectionavailableEventListener(eventHandler, receiver);
   EXPECT_CALL(*eventHandler, handleEvent(testing::_, testing::_)).Times(1);
 
   receiver->connectionList(scope.getScriptState());
 
-  WebPresentationSessionInfo sessionInfo(KURL(KURL(), "http://example.com"),
-                                         "id");
+  WebPresentationInfo presentationInfo(KURL(KURL(), "http://example.com"),
+                                       "id");
   // Receive first connection.
-  receiver->onReceiverConnectionAvailable(sessionInfo);
+  receiver->onReceiverConnectionAvailable(presentationInfo);
   // Receive second connection.
-  receiver->onReceiverConnectionAvailable(sessionInfo);
+  receiver->onReceiverConnectionAvailable(presentationInfo);
 
   verifyConnectionListSize(2, receiver);
 }
 
 TEST_F(PresentationReceiverTest, TwoConnectionsNoEvent) {
   V8TestingScope scope;
   auto receiver = new PresentationReceiver(&scope.frame(), nullptr);
 
   StrictMock<MockEventListener>* eventHandler =
       new StrictMock<MockEventListener>();
   addConnectionavailableEventListener(eventHandler, receiver);
   EXPECT_CALL(*eventHandler, handleEvent(testing::_, testing::_)).Times(0);
 
-  WebPresentationSessionInfo sessionInfo(KURL(KURL(), "http://example.com"),
-                                         "id");
+  WebPresentationInfo presentationInfo(KURL(KURL(), "http://example.com"),
+                                       "id");
   // Receive first connection.
-  auto* connection1 = receiver->onReceiverConnectionAvailable(sessionInfo);
+  auto* connection1 = receiver->onReceiverConnectionAvailable(presentationInfo);
   EXPECT_TRUE(connection1);
 
   // Receive second connection.
-  auto* connection2 = receiver->onReceiverConnectionAvailable(sessionInfo);
+  auto* connection2 = receiver->onReceiverConnectionAvailable(presentationInfo);
   EXPECT_TRUE(connection2);
 
   receiver->connectionList(scope.getScriptState());
   verifyConnectionListPropertyState(ScriptPromisePropertyBase::Resolved,
                                     receiver);
   verifyConnectionListSize(2, receiver);
 }
 
 TEST_F(PresentationReceiverTest, CreateReceiver) {
   MockWebPresentationClient client;
   EXPECT_CALL(client, setReceiver(testing::_));
 
   V8TestingScope scope;
   new PresentationReceiver(&scope.frame(), &client);
 }
 
 }  // namespace blink