[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 105 matching lines @@
     }
   }
 
   MOCK_METHOD0(InvokeObserver, void());
 
  private:
   ScopedVector<content::PresentationSessionMessage> expected_messages_;
   bool pass_ownership_;
 };
 
+class PresentationConnectionStateChangeHandler {

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

How about PresentatonConnectionStateChangeCallback and name the mock method Run?

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

Done.

+ public:
+  MOCK_METHOD2(Invoke,
+               void(const content::PresentationSessionInfo&,
+                    content::PresentationConnectionState));
+};
+
 template <typename T>
 void StoreAndRun(T* result, const base::Closure& closure, const T& result_val) {
   *result = result_val;
   closure.Run();
 }
 
 class MediaRouterMojoImplTest : public MediaRouterMojoTest {
  public:
   MediaRouterMojoImplTest() {}
   ~MediaRouterMojoImplTest() override {}
@@ skipping 595 matching lines @@
 
   mojo_callback.Run(mojo::Array<interfaces::RouteMessagePtr>(0), true);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationConnectionStateObserver) {
   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);
+  PresentationConnectionStateChangeHandler handler;
+  PresentationConnectionStateObserver observer(
+      base::Bind(&PresentationConnectionStateChangeHandler::Invoke,
+                 base::Unretained(&handler)),
+      connection, route_id, router());
 
-  EXPECT_CALL(observer,
-              OnStateChanged(content::PRESENTATION_CONNECTION_STATE_CLOSED));
+  EXPECT_CALL(handler, Invoke(_, 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_CALL(handler,
+              Invoke(_, content::PRESENTATION_CONNECTION_STATE_TERMINATED))
+      .Times(1);
   media_router_proxy_->OnPresentationConnectionStateChanged(
       route_id,
       PresentationConnectionState::PRESENTATION_CONNECTION_STATE_TERMINATED);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .WillRepeatedly(Return(true));
@@ skipping 208 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