[Media Router] Connection state change listening redesign part 2.

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 <vector>
 
 #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"
@@ skipping 27 matching lines @@
 };
 
 class MockDefaultPresentationRequestObserver
     : public PresentationServiceDelegateImpl::
           DefaultPresentationRequestObserver {
  public:
   MOCK_METHOD1(OnDefaultPresentationChanged, void(const PresentationRequest&));
   MOCK_METHOD0(OnDefaultPresentationRemoved, void());
 };
 
+class MockCreatePresentationConnnectionCallbacks {
+ public:
+  MOCK_METHOD1(OnCreateConnectionSuccess,
+               void(const content::PresentationSessionInfo& connection));
+  MOCK_METHOD1(OnCreateConnectionError,
+               void(const content::PresentationError& error));
+};
+
 class PresentationServiceDelegateImplTest
     : public ChromeRenderViewHostTestHarness {
  public:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     content::WebContents* wc = web_contents();
     ASSERT_TRUE(wc);
     PresentationServiceDelegateImpl::CreateForWebContents(wc);
     delegate_impl_ = PresentationServiceDelegateImpl::FromWebContents(wc);
     delegate_impl_->SetMediaRouterForTest(&router_);
@@ skipping 60 matching lines @@
       render_process_id, render_frame_id, source1.id()));
 
   EXPECT_CALL(router_, UnregisterMediaSinksObserver(_)).Times(1);
   delegate_impl_->RemoveScreenAvailabilityListener(render_process_id,
                                                    render_frame_id, &listener1);
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source1.id()));
 }
 
 // TODO(imcheng): Add a test to set default presentation URL in a different
-// RenderFrameHost and verify that it works.
+// RenderFrameHost and verify that it is ignored.
 TEST_F(PresentationServiceDelegateImplTest, SetDefaultPresentationUrl) {
   EXPECT_FALSE(delegate_impl_->HasDefaultPresentationRequest());
 
   GURL frame_url("http://www.google.com");
   content::WebContentsTester::For(web_contents())->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = web_contents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
@@ skipping 112 matching lines @@
   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);
 }
 
+TEST_F(PresentationServiceDelegateImplTest, ListenForConnnectionStateChange) {
+  GURL frame_url("http://www.google.com");
+  content::WebContentsTester::For(web_contents())->NavigateAndCommit(frame_url);
+  content::RenderFrameHost* main_frame = web_contents()->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(_, _, _, _, _))
+      .WillOnce(SaveArg<4>(&route_response_callbacks));
+
+  const std::string kPresentationUrl("http://url1.fakeUrl");
+  const std::string kPresentationId("pid");
+  MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
+  delegate_impl_->JoinSession(
+      render_process_id, routing_id, kPresentationUrl, 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);
+  MediaRoute route("routeId", MediaSourceForPresentationUrl(kPresentationUrl),
+                   "mediaSinkId", "description", true, "", true);
+  for (const auto& route_response_callback : route_response_callbacks)
+    route_response_callback.Run(&route, kPresentationId, "");
+
+  MockPresentationConnectionStateChangedCallback mock_callback;
+  content::PresentationConnectionStateChangedCallback callback =
+      base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                 base::Unretained(&mock_callback));
+  content::PresentationSessionInfo connection(kPresentationUrl,
+                                              kPresentationId);
+  EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
+                           Equals(callback)));
+  delegate_impl_->ListenForConnectionStateChange(render_process_id, routing_id,
+                                                 connection, callback);
+}
+
 TEST_F(PresentationServiceDelegateImplTest, Reset) {
   ON_CALL(router_, RegisterMediaSinksObserver(_)).WillByDefault(Return(true));
 
   std::string presentation_url1("http://url1.fakeUrl");
   MediaSource source = MediaSourceForPresentationUrl(presentation_url1);
   MockScreenAvailabilityListener listener1(presentation_url1);
   int render_process_id = 1;
   int render_frame_id = 0;
 
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
@@ skipping 31 matching lines @@
   MockScreenAvailabilityListener listener(presentation_url);
   const int render_process_id = 10;
   const int render_frame_id = 1;
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).Times(1);
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener));
 }
 
 }  // namespace media_router