[Presentation API] Add support to content/ for multiple URLs per PresentationRequest.

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 <vector>
-
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mock_screen_availability_listener.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
@@ skipping 61 matching lines @@
 
   void RunDefaultPresentationUrlCallbackTest(bool incognito) {
     content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
     ASSERT_TRUE(main_frame);
     int render_process_id = main_frame->GetProcess()->GetID();
     int routing_id = main_frame->GetRoutingID();
 
     auto callback = base::Bind(
         &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
         base::Unretained(this));
+    std::vector<std::string> urls(1);

[dcheng, 2016/08/26 18:13:33]

std::vector<std::string> urls = {"http://foo.fakeUrl"}; here and elsewhere will
save some typing

[mark a. foltz, 2016/08/29 23:54:54]

Done.

     std::string presentation_url1("http://foo.fakeUrl");
-    delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id,
-                                              presentation_url1, callback);
+    urls[0] = presentation_url1;
+    delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                               urls, callback);
 
     ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
     PresentationRequest request =
         delegate_impl_->GetDefaultPresentationRequest();
 
     // 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));
@@ skipping 167 matching lines @@
       ->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
   auto callback = base::Bind(
       &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
       base::Unretained(this));
   std::string presentation_url1("http://foo.fakeUrl");
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id,
-                                            presentation_url1, callback);
+  std::vector<std::string> urls(1);
+  urls[0] = presentation_url1;
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             urls, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request1 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_EQ(presentation_url1, request1.presentation_url());
   EXPECT_EQ(RenderFrameHostId(render_process_id, routing_id),
             request1.render_frame_host_id());
   EXPECT_EQ(frame_url, request1.frame_url());
 
   // Set to a new default presentation URL
   std::string presentation_url2("https://youtube.com");
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id,
-                                            presentation_url2, callback);
+  urls[0] = presentation_url2;
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             urls, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request2 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_EQ(presentation_url2, request2.presentation_url());
   EXPECT_EQ(RenderFrameHostId(render_process_id, routing_id),
             request2.render_frame_host_id());
   EXPECT_EQ(frame_url, request2.frame_url());
 
   // Remove default presentation URL.
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, "",
-                                            callback);
+  delegate_impl_->SetDefaultPresentationUrls(
+      render_process_id, routing_id, std::vector<std::string>(), callback);
   EXPECT_FALSE(delegate_impl_->HasDefaultPresentationRequest());
 }
 
 TEST_F(PresentationServiceDelegateImplTest, DefaultPresentationUrlCallback) {
   RunDefaultPresentationUrlCallbackTest(false);
 }
 
 TEST_F(PresentationServiceDelegateImplIncognitoTest,
        DefaultPresentationUrlCallback) {
   RunDefaultPresentationUrlCallbackTest(true);
@@ skipping 14 matching lines @@
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
   std::string url1("http://foo.fakeUrl");
   PresentationRequest observed_request1(
       RenderFrameHostId(render_process_id, routing_id), url1, frame_url);
   EXPECT_CALL(observer, OnDefaultPresentationChanged(Equals(observed_request1)))
       .Times(1);
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, url1,
-                                            callback);
+  std::vector<std::string> urls(1);
+  urls[0] = url1;
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             urls, callback);
 
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request1 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_TRUE(request1.Equals(observed_request1));
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
 
   std::string url2("http://youtube.com");
   PresentationRequest observed_request2(
       RenderFrameHostId(render_process_id, routing_id), url2, frame_url);
   EXPECT_CALL(observer, OnDefaultPresentationChanged(Equals(observed_request2)))
       .Times(1);
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, url2,
-                                            callback);
+  urls[0] = url2;
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             urls, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request2 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_TRUE(request2.Equals(observed_request2));
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
 
   // Remove default presentation URL.
   EXPECT_CALL(observer, OnDefaultPresentationRemoved()).Times(1);
-  delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, "",
-                                            callback);
+  delegate_impl_->SetDefaultPresentationUrls(
+      render_process_id, routing_id, std::vector<std::string>(), callback);

[dcheng, 2016/08/26 18:13:33]

Similarly, you can just put "{}" here instead of writing
std::vector<std::string>()

[mark a. foltz, 2016/08/29 23:54:54]

It doesn't allow you to take a reference to a temporary constant expression:

error: chosen constructor is explicit in copy-initialization  

 }
 
 TEST_F(PresentationServiceDelegateImplTest, ListenForConnnectionStateChange) {
   GURL frame_url("http://www.google.com");
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
   // Set up a PresentationConnection so we can listen to it.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   EXPECT_CALL(router_, JoinRoute(_, _, _, _, _, _, false))
       .WillOnce(SaveArg<4>(&route_response_callbacks));
 
   const std::string kPresentationUrl("http://url1.fakeUrl");
   const std::string kPresentationId("pid");
+  std::vector<std::string> urls(1);
+  urls[0] = kPresentationUrl;
   MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
   delegate_impl_->JoinSession(
-      render_process_id, routing_id, kPresentationUrl, kPresentationId,
+      render_process_id, routing_id, urls, 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(
@@ skipping 65 matching lines @@
   int render_process_id = main_frame->GetProcess()->GetID();
   int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(false));
   EXPECT_CALL(listener, OnScreenAvailabilityNotSupported());
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener));
 }
 
 }  // namespace media_router