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

chrome/browser/media/router/media_router_mojo_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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 723 matching lines @@
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   ProcessEventLoop();
 
   mojo_callback.Run(mojo::Array<interfaces::RouteMessagePtr>(0), true);
   ProcessEventLoop();
 }
 
-TEST_F(MediaRouterMojoImplTest, PresentationConnectionStateObserver) {
+TEST_F(MediaRouterMojoImplTest, PresentationConnectionStateChangedCallback) {
   using PresentationConnectionState =
       interfaces::MediaRouter::PresentationConnectionState;
 
   MediaRoute::Id route_id("route-id");
-  MockPresentationConnectionStateObserver observer(router(), route_id);
+  const std::string kPresentationUrl("http://foo.fakeUrl");
+  const std::string kPresentationId("pid");
+  content::PresentationSessionInfo connection(kPresentationUrl,
+                                              kPresentationId);
+  MockPresentationConnectionStateChangedCallback callback;
+  scoped_ptr<PresentationConnectionStateSubscription> subscription =
+      router()->AddPresentationConnectionStateChangedCallback(
+          route_id,
+          base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                     base::Unretained(&callback)));
 
-  EXPECT_CALL(observer,
-              OnStateChanged(content::PRESENTATION_CONNECTION_STATE_CLOSED));
+  EXPECT_CALL(callback, Run(content::PRESENTATION_CONNECTION_STATE_CLOSED))
+      .Times(1);
   media_router_proxy_->OnPresentationConnectionStateChanged(
       route_id,
       PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CLOSED);
   ProcessEventLoop();
 
-  EXPECT_CALL(observer, OnStateChanged(
-                            content::PRESENTATION_CONNECTION_STATE_TERMINATED));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback));
+
+  // Right now we don't keep track of previous state so the callback will be
+  // invoked with the same state again.
+  EXPECT_CALL(callback, Run(content::PRESENTATION_CONNECTION_STATE_CLOSED))
+      .Times(1);
   media_router_proxy_->OnPresentationConnectionStateChanged(
       route_id,
-      PresentationConnectionState::PRESENTATION_CONNECTION_STATE_TERMINATED);
+      PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CLOSED);
+  ProcessEventLoop();
+
+  // Callback has been removed, so we don't expect it to be called anymore.
+  subscription.reset();
+  EXPECT_CALL(callback, Run(content::PRESENTATION_CONNECTION_STATE_CLOSED))
+      .Times(0);
+  media_router_proxy_->OnPresentationConnectionStateChanged(
+      route_id,
+      PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CLOSED);
   ProcessEventLoop();

[mark a. foltz, 2015/11/18 00:39:38]

Is there test coverage for the removal callback?

[imcheng, 2015/11/19 23:39:53]

Added assertion that the CallbackList entry is removed after Subscription object
is destroyed.

 }
 
 TEST_F(MediaRouterMojoImplTest, HasLocalRoute) {
   EXPECT_FALSE(router()->HasLocalDisplayRoute());
   interfaces::MediaRoutePtr mojo_route1 = interfaces::MediaRoute::New();
   mojo_route1->media_route_id = "routeId1";
   mojo_route1->media_sink_id = "sinkId";
   mojo_route1->is_local = false;
   mojo_route1->for_display = false;
   router()->RouteResponseReceived("presentationId1",
@@ skipping 247 matching lines @@
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests);
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 }
 
 }  // namespace media_router