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

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"
 
 using ::testing::_;
 using ::testing::Invoke;
 using blink::WebArrayBuffer;
 using blink::WebPresentationAvailabilityCallbacks;
 using blink::WebPresentationAvailabilityObserver;
-using blink::WebPresentationConnectionCallback;
+using blink::WebPresentationConnectionCallbacks;
 using blink::WebPresentationError;
 using blink::WebPresentationSessionInfo;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 using blink::mojom::PresentationConnection;
 using blink::mojom::PresentationError;
 using blink::mojom::PresentationErrorPtr;
 using blink::mojom::PresentationErrorType;
 using blink::mojom::PresentationService;
@@ skipping 77 matching lines @@
       blink::mojom::PresentationConnectionPtr controller_conn_ptr,
       blink::mojom::PresentationConnectionRequest receiver_conn_request)
       override {
     SetPresentationConnection(session.get(), controller_conn_ptr.get());
   }
   MOCK_METHOD2(SetPresentationConnection,
                void(PresentationSessionInfo* session_info,
                     PresentationConnection* connection));
 };
 
+class TestPresentationConnection : public blink::WebPresentationConnection {

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

Is this identical to the one in presentation_connection_proxy_unittest.cc?  If
so, can it be factored out into a test support class?

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

Done.

+ public:
+  void bindProxy(
+      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 TestWebPresentationConnectionCallback
-    : public WebPresentationConnectionCallback {
+    : 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 &connection_;
+  }
+
  private:
   const WebURL url_;
   const WebString id_;
   bool callback_called_;
+  TestPresentationConnection connection_;
 };
 
 class TestWebPresentationConnectionErrorCallback
-    : public WebPresentationConnectionCallback {
+    : public WebPresentationConnectionCallbacks {
  public:
   TestWebPresentationConnectionErrorCallback(
       WebPresentationError::ErrorType error_type,
       WebString message)
       : error_type_(error_type), message_(message), callback_called_(false) {}
   ~TestWebPresentationConnectionErrorCallback() override {
     EXPECT_TRUE(callback_called_);
   }
 
   void onError(const WebPresentationError& error) override {
     callback_called_ = true;
     EXPECT_EQ(error.errorType, error_type_);
     EXPECT_EQ(error.message, message_);
   }
 
+  blink::WebPresentationConnection* getConnection() override { return nullptr; }
+
  private:
   const WebPresentationError::ErrorType error_type_;
   const WebString message_;
   bool callback_called_;
 };
 
 class TestPresentationDispatcher : public PresentationDispatcher {
  public:
   explicit TestPresentationDispatcher(
       MockPresentationService* presentation_service)
@@ skipping 145 matching lines @@
       .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);
       }));
-  dispatcher_.sendString(url1_, presentation_id_, message);
+  dispatcher_.sendString(url1_, presentation_id_, message, nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendArrayBuffer) {
   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);
         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());
+                              array_buffer_.byteLength(), nullptr);
   run_loop.RunUntilIdle();
 }
 
 TEST_F(PresentationDispatcherTest, TestSendBlobData) {
   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);
         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());
+                           array_buffer_.byteLength(), nullptr);
   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();
 }
@@ skipping 37 matching lines @@
 }
 
 TEST_F(PresentationDispatcherTest, TestSetDefaultPresentationUrls) {
   base::RunLoop run_loop;
   EXPECT_CALL(presentation_service_, SetDefaultPresentationUrls(gurls_));
   dispatcher_.setDefaultPresentationUrls(urls_);
   run_loop.RunUntilIdle();
 }
 
 }  // namespace content