[Media Router] Add a presentation id to MediaRoute mapping in the MR

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/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
@@ skipping 127 matching lines @@
         base::Unretained(this));
     std::vector<std::string> urls({kPresentationUrl1});
     delegate_impl_->SetDefaultPresentationUrls(main_frame_process_id_,
                                                main_frame_routing_id_,
                                                presentation_urls_, callback);
 
     ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
     PresentationRequest request =
         delegate_impl_->GetDefaultPresentationRequest();
 
+    EXPECT_CALL(router_, RegisterPresentationRoute(_, _)).Times(2);
+
     // Should not trigger callback since route response is error.
     std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromError(
         "Error", RouteRequestResult::UNKNOWN_ERROR);
     delegate_impl_->OnRouteResponse(request, *result);
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 
     // Should not trigger callback since request doesn't match.
     PresentationRequest different_request(RenderFrameHostId(100, 200),
                                           {presentation_url2_},
                                           url::Origin(GURL(kFrameUrl)));
@@ skipping 263 matching lines @@
       kPresentationId,
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
           &MockCreatePresentationConnnectionCallbacks::OnCreateConnectionError,
           base::Unretained(&mock_create_connection_callbacks)));
 
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionSuccess(_))
       .Times(1);
-  std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromSuccess(
-      MediaRoute("routeId", source1_, "mediaSinkId", "description", true, "",
-                 true),
-      kPresentationId);
+  MediaRoute media_route("routeId", source1_, "mediaSinkId", "description",
+                         true, "", true);
+  std::unique_ptr<RouteRequestResult> result =
+      RouteRequestResult::FromSuccess(media_route, kPresentationId);
+  EXPECT_CALL(router_,
+              RegisterPresentationRoute(kPresentationId, Equals(media_route)));
+
   for (const auto& route_response_callback : route_response_callbacks)
     route_response_callback.Run(*result);
 
   base::MockCallback<content::PresentationConnectionStateChangedCallback>
       mock_callback;
   auto callback = mock_callback.Get();
   content::PresentationSessionInfo connection(presentation_url1_,
                                               kPresentationId);
   EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
                            Equals(callback)));
@@ skipping 51 matching lines @@
                                                 presentation_id);
 
   base::MockCallback<
       base::Callback<void(const content::PresentationSessionInfo&)>>
       mock_callback;
   EXPECT_CALL(mock_callback, Run(_));
   MediaRoute media_route(
       "route_id", MediaSourceForPresentationUrl(session_info.presentation_url),
       "mediaSinkId", "", true, "", true);
   media_route.set_offscreen_presentation(true);
+  EXPECT_CALL(router_,
+              RegisterPresentationRoute(presentation_id, Equals(media_route)));
+
   delegate_impl_->OnStartSessionSucceeded(render_process_id, render_frame_id,
                                           mock_callback.Get(), session_info,
                                           media_route);
 
   OffscreenPresentationManagerFactory::GetInstanceForTest()->SetTestingFactory(
       profile(), &BuildMockOffscreenPresentationManager);
   MockOffscreenPresentationManager* mock_offscreen_manager =
       static_cast<MockOffscreenPresentationManager*>(
           OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext(
               profile()));
   EXPECT_CALL(*mock_offscreen_manager,
               RegisterOffscreenPresentationController(
                   presentation_id, presentation_url,
                   RenderFrameHostId(render_process_id, render_frame_id)));
 
   content::PresentationConnectionPtr connection_ptr;
   content::PresentationConnectionRequest connection_request;
   delegate_impl_->ConnectToPresentation(render_process_id, render_frame_id,
                                         session_info, std::move(connection_ptr),
                                         std::move(connection_request));
 
   EXPECT_CALL(*mock_offscreen_manager,
               UnregisterOffscreenPresentationController(
                   presentation_id,
                   RenderFrameHostId(render_process_id, render_frame_id)));
   EXPECT_CALL(router_, DetachRoute("route_id"));
+  EXPECT_CALL(router_, UnregisterPresentationRoute(presentation_id));
+
   delegate_impl_->Reset(render_process_id, render_frame_id);
 }
 
 #if !defined(OS_ANDROID)
 TEST_F(PresentationServiceDelegateImplTest, AutoJoinRequest) {
   GURL frame_url(kFrameUrl);
   std::string origin(url::Origin(frame_url).Serialize());
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
 
@@ skipping 93 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