[Media Router] Clean up OffscreenPresentationManager params.

chrome/browser/media/router/presentation_service_delegate_impl_unittest.cc

 // Copyright 2015 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 "chrome/browser/media/router/presentation_service_delegate_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/test/mock_callback.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mock_screen_availability_listener.h"
@@ skipping 25 matching lines @@
 using ::testing::WithArgs;
 
 namespace {
 
 const char kPresentationUrl1[] = "http://foo.fakeurl.com/";
 const char kPresentationUrl2[] = "http://bar.fakeurl.com/";
 const char kPresentationUrl3[] =
     "https://google.com/cast#__castAppId__=233637DE";
 const char kFrameUrl[] = "http://anotherframeurl.fakeurl.com/";
 
+// Matches content::PresentationInfo.
+MATCHER_P(InfoEquals, expected, "") {
+  return expected.presentation_url == arg.presentation_url &&
+         expected.presentation_id == arg.presentation_id;
+}
+
 }  // namespace
 
 namespace media_router {
 
 class MockDelegateObserver
     : public content::PresentationServiceDelegate::Observer {
  public:
   MOCK_METHOD0(OnDelegateDestroyed, void());
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationInfo&));
@@ skipping 11 matching lines @@
  public:
   MOCK_METHOD1(OnCreateConnectionSuccess,
                void(const content::PresentationInfo& connection));
   MOCK_METHOD1(OnCreateConnectionError,
                void(const content::PresentationError& error));
 };
 
 class MockOffscreenPresentationManager : public OffscreenPresentationManager {
  public:
   void RegisterOffscreenPresentationController(
-      const std::string& presentation_id,
-      const GURL& presentation_url,
+      const content::PresentationInfo& presentation_info,
       const RenderFrameHostId& render_frame_id,
       content::PresentationConnectionPtr controller,
       content::PresentationConnectionRequest,
       const MediaRoute& route) override {
-    RegisterOffscreenPresentationController(presentation_id, presentation_url,
-                                            render_frame_id, route);
+    RegisterOffscreenPresentationController(presentation_info, render_frame_id,
+                                            route);
   }
 
-  MOCK_METHOD4(RegisterOffscreenPresentationController,
-               void(const std::string& presentation_id,
-                    const GURL& presentation_url,
+  MOCK_METHOD3(RegisterOffscreenPresentationController,
+               void(const content::PresentationInfo& presentation_info,
                     const RenderFrameHostId& render_frame_id,
                     const MediaRoute& route));
   MOCK_METHOD2(UnregisterOffscreenPresentationController,
                void(const std::string& presentation_id,
                     const RenderFrameHostId& render_frame_id));
-  MOCK_METHOD3(OnOffscreenPresentationReceiverCreated,
-               void(const std::string& presentation_id,
-                    const GURL& presentation_url,
+  MOCK_METHOD2(OnOffscreenPresentationReceiverCreated,
+               void(const content::PresentationInfo& presentation_info,
                     const content::ReceiverConnectionAvailableCallback&
                         receiver_callback));
   MOCK_METHOD1(OnOffscreenPresentationReceiverTerminated,
                void(const std::string& presentation_id));
   MOCK_METHOD1(IsOffscreenPresentation,
                bool(const std::string& presentation_id));
   MOCK_METHOD1(GetRoute, MediaRoute*(const std::string& presentation_id));
 };
 
 std::unique_ptr<KeyedService> BuildMockOffscreenPresentationManager(
@@ skipping 499 matching lines @@
   base::MockCallback<content::PresentationConnectionCallback> success_cb;
   EXPECT_CALL(success_cb, Run(_));
 
   delegate_impl_->OnStartPresentationSucceeded(
       render_process_id, render_frame_id, success_cb.Get(), presentation_info,
       media_route);
 
   auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
   EXPECT_CALL(mock_offscreen_manager,
               RegisterOffscreenPresentationController(
-                  presentation_id, presentation_url,
+                  InfoEquals(presentation_info),
                   RenderFrameHostId(render_process_id, render_frame_id),
                   Equals(media_route)));
 
   content::PresentationConnectionPtr connection_ptr;
   content::PresentationConnectionRequest connection_request;
   delegate_impl_->ConnectToPresentation(
       render_process_id, render_frame_id, presentation_info,
       std::move(connection_ptr), std::move(connection_request));
 
   EXPECT_CALL(mock_offscreen_manager,
@@ skipping 159 matching lines @@
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
           &MockCreatePresentationConnnectionCallbacks::OnCreateConnectionError,
           base::Unretained(&mock_create_connection_callbacks)));
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router