[Media Router] Clean up OffscreenPresentationManager params.

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"
@@ skipping 22 matching lines @@
 
   MOCK_METHOD2(OnReceiverConnectionAvailableRaw,
                void(const content::PresentationInfo&,
                     blink::mojom::PresentationConnection*));
 };
 
 class OffscreenPresentationManagerTest : public ::testing::Test {
  public:
   OffscreenPresentationManagerTest()
       : render_frame_host_id_(1, 1),
-        presentation_url_(kPresentationUrl),
+        presentation_info_(GURL(kPresentationUrl), kPresentationId),
         route_("route_1",
                MediaSource("source_1"),
                "sink_1",
                "",
                false,
                "",
                false) {}
 
   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(receiver_conn_request), route_);
+    RegisterController(
+        content::PresentationInfo(GURL(kPresentationUrl), presentation_id),
+        render_frame_host_id_, std::move(controller));
   }
 
   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(receiver_conn_request), route_);
+    RegisterController(presentation_info_, render_frame_id,
+                       std::move(controller));
   }
 
   void RegisterController(content::PresentationConnectionPtr controller) {
+    RegisterController(presentation_info_, render_frame_host_id_,
+                       std::move(controller));
+  }
+
+  void RegisterController(const content::PresentationInfo& presentation_info,
+                          const RenderFrameHostId& render_frame_id,
+                          content::PresentationConnectionPtr controller) {
     content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
-        kPresentationId, presentation_url_, render_frame_host_id_,
-        std::move(controller), std::move(receiver_conn_request), route_);
+        presentation_info, render_frame_id, std::move(controller),
+        std::move(receiver_conn_request), route_);
   }
 
   void RegisterReceiver(
       MockReceiverConnectionAvailableCallback& receiver_callback) {
     RegisterReceiver(kPresentationId, receiver_callback);
   }
 
   void RegisterReceiver(
       const std::string& presentation_id,
       MockReceiverConnectionAvailableCallback& receiver_callback) {
     manager()->OnOffscreenPresentationReceiverCreated(
-        presentation_id, presentation_url_,
+        content::PresentationInfo(GURL(kPresentationUrl), presentation_id),
         base::Bind(&MockReceiverConnectionAvailableCallback::
                        OnReceiverConnectionAvailable,
                    base::Unretained(&receiver_callback)));
   }
 
   void UnregisterController(const RenderFrameHostId& render_frame_id) {
     manager()->UnregisterOffscreenPresentationController(kPresentationId,
                                                          render_frame_id);
   }
 
   void UnregisterController() {
     manager()->UnregisterOffscreenPresentationController(kPresentationId,
                                                          render_frame_host_id_);
   }
 
   void UnregisterReceiver() {
     manager()->OnOffscreenPresentationReceiverTerminated(kPresentationId);
   }
 
  private:
   const RenderFrameHostId render_frame_host_id_;
-  GURL presentation_url_;
+  const content::PresentationInfo presentation_info_;
   OffscreenPresentationManager manager_;
   MediaRoute route_;
 };
 
 TEST_F(OffscreenPresentationManagerTest, RegisterUnregisterController) {
   content::PresentationConnectionPtr controller;
   RegisterController(std::move(controller));
   VerifyPresentationsSize(1);
   UnregisterController();
   VerifyPresentationsSize(0);
@@ skipping 190 matching lines @@
   EXPECT_FALSE(manager()->GetRoute(kPresentationId));
   content::PresentationConnectionPtr controller;
   RegisterController(std::move(controller));
 
   auto* actual_route = manager()->GetRoute(kPresentationId);
   EXPECT_TRUE(actual_route);
   EXPECT_TRUE(route.Equals(*actual_route));
 }
 
 }  // namespace media_router