[Presentation API] (3rd) (1-UA) Split PresentationServiceDelegateImpl(PSDImpl)

chrome/browser/media/router/offscreen_presentation_manager_unittest.cc

 // 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 <vector>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/media/router/offscreen_presentation_manager.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using testing::_;
 
 namespace media_router {
 
 namespace {
 const char kPresentationId[] = "presentationId";
 const char kPresentationId2[] = "presentationId2";
 const char kPresentationUrl[] = "http://www.example.com/presentation.html";
 }  // namespace
 
 class MockReceiverConnectionAvailableCallback {
  public:
   void OnReceiverConnectionAvailable(
       const content::PresentationSessionInfo& session_info,
-      content::PresentationConnectionPtr connection_ptr) {
-    OnReceiverConnectionAvailableRaw(session_info, connection_ptr);
+      content::PresentationConnectionPtr controller_conn,
+      content::PresentationConnectionRequest receiver_conn_request) {
+    OnReceiverConnectionAvailableRaw(session_info, controller_conn.get());
   }
 
   MOCK_METHOD2(OnReceiverConnectionAvailableRaw,
                void(const content::PresentationSessionInfo&,
-                    content::PresentationConnectionPtr));
+                    blink::mojom::PresentationConnection*));
 };
 
 class OffscreenPresentationManagerTest : public ::testing::Test {
  public:
   OffscreenPresentationManagerTest()
       : render_frame_host_id_(1, 1), presentation_url_(kPresentationUrl) {}
 
   OffscreenPresentationManager* manager() { return &manager_; }
 
   void VerifyPresentationsSize(size_t expected) {
     EXPECT_EQ(expected, manager_.offscreen_presentations_.size());
   }
 
   void VerifyControllerSize(size_t expected,
                             const std::string& presentationId) {
     EXPECT_TRUE(
         base::ContainsKey(manager_.offscreen_presentations_, presentationId));
     EXPECT_EQ(expected, manager_.offscreen_presentations_[presentationId]
                             ->pending_controllers_.size());
   }
 
   void RegisterController(const std::string& presentation_id,
                           content::PresentationConnectionPtr controller) {
+    content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         presentation_id, presentation_url_, render_frame_host_id_,
-        std::move(controller));
+        std::move(controller), std::move(receiver_conn_request));
   }
 
   void RegisterController(const RenderFrameHostId& render_frame_id,
                           content::PresentationConnectionPtr controller) {
+    content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         kPresentationId, presentation_url_, render_frame_id,
-        std::move(controller));
+        std::move(controller), std::move(receiver_conn_request));
   }
 
   void RegisterController(content::PresentationConnectionPtr controller) {
+    content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         kPresentationId, presentation_url_, render_frame_host_id_,
-        std::move(controller));
+        std::move(controller), std::move(receiver_conn_request));
   }
 
   void RegisterReceiver(
       MockReceiverConnectionAvailableCallback& receiver_callback) {
     RegisterReceiver(kPresentationId, receiver_callback);
   }
 
   void RegisterReceiver(
       const std::string& presentation_id,
       MockReceiverConnectionAvailableCallback& receiver_callback) {
@@ skipping 203 matching lines @@
       .Times(1);
   RegisterReceiver(kPresentationId2, receiver_callback2);
 
   VerifyPresentationsSize(2);
 
   UnregisterReceiver();
   VerifyPresentationsSize(1);
 }
 
 }  // namespace media_router