[Presentation API] (4th)(1-UA blink side) Add WebPresentationConnection and WebPresentationConnecti…

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 "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/frame/LocalFrame.h"
 #include "core/testing/DummyPageHolder.h"
+#include "modules/presentation/PresentationConnection.h"
 #include "modules/presentation/PresentationConnectionList.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "public/platform/modules/presentation/WebPresentationClient.h"
+#include "public/platform/modules/presentation/WebPresentationConnectionProxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 
 class MockEventListener : public EventListener {
  public:
   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(
       const WebVector<WebURL>& presentationUrls,
-      std::unique_ptr<WebPresentationConnectionCallback> callbacks) override {
+      std::unique_ptr<WebPresentationConnectionCallbacks> callbacks) override {
     return startSession_(presentationUrls, callbacks);
   }
   void joinSession(
       const WebVector<WebURL>& presentationUrls,
       const WebString& presentationId,
-      std::unique_ptr<WebPresentationConnectionCallback> callbacks) override {
+      std::unique_ptr<WebPresentationConnectionCallbacks> callbacks) override {
     return joinSession_(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_,
                void(const WebVector<WebURL>& presentationUrls,
-                    std::unique_ptr<WebPresentationConnectionCallback>&));
+                    std::unique_ptr<WebPresentationConnectionCallbacks>&));
 
   MOCK_METHOD3(joinSession_,
                void(const WebVector<WebURL>& presentationUrls,
                     const WebString& presentationId,
-                    std::unique_ptr<WebPresentationConnectionCallback>&));
+                    std::unique_ptr<WebPresentationConnectionCallbacks>&));
 
-  MOCK_METHOD3(sendString,
+  MOCK_METHOD4(sendString,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
-                    const WebString& message));
+                    const WebString& message,
+                    const WebPresentationConnectionProxy* proxy));
 
-  MOCK_METHOD4(sendArrayBuffer,
+  MOCK_METHOD5(sendArrayBuffer,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const uint8_t* data,
-                    size_t length));
+                    size_t length,
+                    const WebPresentationConnectionProxy* proxy));
 
-  MOCK_METHOD4(sendBlobData,
+  MOCK_METHOD5(sendBlobData,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId,
                     const uint8_t* data,
-                    size_t length));
+                    size_t length,
+                    const WebPresentationConnectionProxy* proxy));
 
   MOCK_METHOD2(closeSession,
                void(const WebURL& presentationUrl,
                     const WebString& presentationId));
 
   MOCK_METHOD2(terminateSession,
                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*));
 
   MOCK_METHOD1(setDefaultPresentationUrls, void(const WebVector<WebURL>&));
 };
 
+class MockWebPresentationConnectionProxy

[mark a. foltz, 2017/01/23 20:18:43]

Are tests that exercise this mock coming in patch #5?

[zhaobin, 2017/01/24 01:23:24]

Removed. Not needed here.

+    : public WebPresentationConnectionProxy {
+ public:
+  MOCK_METHOD1(SetSourceConnection, void(blink::WebPresentationConnection*));
+  MOCK_METHOD1(SendString, void(const blink::WebString& message));
+  MOCK_METHOD2(SendArrayBuffer, void(const uint8_t* data, size_t length));
+};
+
 class PresentationReceiverTest : public ::testing::Test {
  public:
   void addConnectionavailableEventListener(EventListener*,
                                            const PresentationReceiver*);
   void verifyConnectionListPropertyState(ScriptPromisePropertyBase::State,
                                          const PresentationReceiver*);
   void verifyConnectionListSize(size_t expectedSize,
                                 const PresentationReceiver*);
 };
 
@@ skipping 97 matching lines @@
 
 TEST_F(PresentationReceiverTest, CreateReceiver) {
   MockWebPresentationClient client;
   EXPECT_CALL(client, setReceiver(testing::_));
 
   V8TestingScope scope;
   new PresentationReceiver(&scope.frame(), &client);
 }
 
 }  // namespace blink