[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 41 matching lines @@
     ChromeRenderViewHostTestHarness::SetUp();
     content::WebContents* wc = web_contents();
     ASSERT_TRUE(wc);
     PresentationServiceDelegateImpl::CreateForWebContents(wc);
     delegate_impl_ = PresentationServiceDelegateImpl::FromWebContents(wc);
     delegate_impl_->SetMediaRouterForTest(&router_);
   }
 
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationSessionInfo& session_info));
+  MOCK_METHOD1(OnCreateConnectionSuccess,
+               void(const content::PresentationSessionInfo& connection));
+  MOCK_METHOD1(OnCreateConnectionError,
+               void(const content::PresentationError& error));
+  MOCK_METHOD2(OnPresentationConnectionStateChanged,
+               void(const content::PresentationSessionInfo& connection,
+                    content::PresentationConnectionState state));
 
   PresentationServiceDelegateImpl* delegate_impl_;
   MockMediaRouter router_;
 };
 
 TEST_F(PresentationServiceDelegateImplTest, AddScreenAvailabilityListener) {
   ON_CALL(router_, RegisterMediaSinksObserver(_)).WillByDefault(Return(true));
 
   std::string presentation_url1("http://url1.fakeUrl");
   std::string presentation_url2("http://url2.fakeUrl");
@@ skipping 46 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> callbacks;
+  EXPECT_CALL(router_, JoinRoute(_, _, _, _, _))
+      .WillOnce(SaveArg<4>(&callbacks));
+
+  const std::string kPresentationUrl("http://url1.fakeUrl");
+  const std::string kPresentationId("pid");
+  delegate_impl_->JoinSession(
+      render_process_id, routing_id, kPresentationUrl, kPresentationId,
+      base::Bind(
+          &PresentationServiceDelegateImplTest::OnCreateConnectionSuccess,
+          base::Unretained(this)),

[mark a. foltz, 2015/11/12 04:19:38]

It's a little weird to bind callbacks to the test itself.  The pattern I would
assume would be to create a separate mock object representing the client of the
API and bind the callbacks to it.  But I don't feel strongly about it.

[imcheng, 2015/11/16 23:52:01]

Done. I refactored the mock object into test_helper.{cc,h}.

+      base::Bind(&PresentationServiceDelegateImplTest::OnCreateConnectionError,
+                 base::Unretained(this)));
+
+  EXPECT_CALL(*this, OnCreateConnectionSuccess(_)).Times(1);
+  MediaRoute route("routeId", MediaSourceForPresentationUrl(kPresentationUrl),
+                   "mediaSinkId", "description", true, "", true);
+  for (const auto& callback : callbacks)
+    callback.Run(&route, kPresentationId, "");
+
+  content::PresentationSessionInfo connection(kPresentationUrl,
+                                              kPresentationId);
+  PresentationConnectionStateObserver* state_observer = nullptr;
+  EXPECT_CALL(router_, RegisterPresentationConnectionStateObserver(_))
+      .WillOnce(SaveArg<0>(&state_observer));
+  delegate_impl_->ListenForConnectionStateChange(
+      render_process_id, routing_id, connection,
+      base::Bind(&PresentationServiceDelegateImplTest::
+                     OnPresentationConnectionStateChanged,
+                 base::Unretained(this)));
+  ASSERT_TRUE(state_observer);
+  EXPECT_EQ(route.media_route_id(), state_observer->route_id());
+
+  EXPECT_CALL(*this, OnPresentationConnectionStateChanged(
+                         _, content::PRESENTATION_CONNECTION_STATE_CLOSED))
+      .Times(1);
+  state_observer->OnStateChanged(content::PRESENTATION_CONNECTION_STATE_CLOSED);
+
+  EXPECT_CALL(*this, OnPresentationConnectionStateChanged(
+                         _, content::PRESENTATION_CONNECTION_STATE_TERMINATED))

[mark a. foltz, 2015/11/12 04:19:38]

Strictly speaking, CLOSED is a terminal state for the PresentationConnection so
you wouldn't see a transition from CLOSED to TERMINATED in real usage.

[imcheng, 2015/11/16 23:52:01]

Ack. That part has been moved to media_router_mojo_impl_unittest.cc.

+      .Times(1);
+  state_observer->OnStateChanged(
+      content::PRESENTATION_CONNECTION_STATE_TERMINATED);
+}
+
 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