[Media Router] 2nd take on fix route response callback lifetime in UI.

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 45 matching lines @@
       expected->presentation_id != actual->presentation_id ||
       expected->type != actual->type) {
     return false;
   }
   return expected->is_binary() ? *(expected->data) == *(actual->data)
                                : *(expected->message) == *(actual->message);
 }
 
 }  // namespace
 
-// Adapts Invoke(), which takes a move-only scoped_ptr parameter (not mockable)
-// to a variant that accepts raw pointers instead (mock friendly).
 class RouteResponseCallbackHandler {
  public:
-  void Invoke(scoped_ptr<MediaRoute> route, const std::string& error_text) {
-    InvokeObserver(route.get(), error_text);
-  }
-
-  MOCK_METHOD2(InvokeObserver,
-               void(MediaRoute* route, const std::string& error_text));
+  MOCK_METHOD2(Invoke,
+               void(const MediaRoute* route, const std::string& error_text));
 };
 
 class SendMessageCallbackHandler {
  public:
   MOCK_METHOD1(Invoke, void(bool));
 };
 
 class ListenForMessagesCallbackHandler {
  public:
   ListenForMessagesCallbackHandler(scoped_ptr<
@@ skipping 79 matching lines @@
                           mojo::String(kOrigin), kTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& sink,
           const mojo::String& presentation_id, const mojo::String& origin,
           int tab_id,
           const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
         cb.Run(route.Pass(), mojo::String());
       }));
 
   RouteResponseCallbackHandler handler;
-  EXPECT_CALL(handler, InvokeObserver(Pointee(Equals(expected_route)), ""));
+  EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), ""));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(kSource, kSink, GURL(kOrigin), kTabId,
-                        base::Bind(&RouteResponseCallbackHandler::Invoke,
-                                   base::Unretained(&handler)));
+                        route_response_callbacks);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSink), _,
                           mojo::String(kOrigin), kTabId, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
              int tab_id,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
           }));
 
   RouteResponseCallbackHandler handler;
-  EXPECT_CALL(handler, InvokeObserver(nullptr, kError));
+  EXPECT_CALL(handler, Invoke(nullptr, kError));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(kSource, kSink, GURL(kOrigin), kTabId,
-                        base::Bind(&RouteResponseCallbackHandler::Invoke,
-                                   base::Unretained(&handler)));
+                        route_response_callbacks);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRoute) {
   MediaRoute expected_route(kRouteId, MediaSource(std::string(kSource)),
                             MediaSink(kSink, kSinkName), "", false);
   interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
   route->media_source = kSource;
   route->media_sink = interfaces::MediaSink::New();
   route->media_sink->sink_id = kSink;
   route->media_sink->name = kSinkName;
   route->media_route_id = kRouteId;
   route->description = kDescription;
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                         mojo::String(kOrigin), kTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(route.Pass(), mojo::String());
       }));
 
   RouteResponseCallbackHandler handler;
-  EXPECT_CALL(handler, InvokeObserver(Pointee(Equals(expected_route)), ""));
+  EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), ""));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), kTabId,
-                      base::Bind(&RouteResponseCallbackHandler::Invoke,
-                                 base::Unretained(&handler)));
+                      route_response_callbacks);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteFails) {
   EXPECT_CALL(mock_media_route_provider_,
               JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                         mojo::String(kOrigin), kTabId, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& presentation_id,
              const mojo::String& origin, int tab_id,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
           }));
 
   RouteResponseCallbackHandler handler;
-  EXPECT_CALL(handler, InvokeObserver(nullptr, kError));
+  EXPECT_CALL(handler, Invoke(nullptr, kError));
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), kTabId,
-                      base::Bind(&RouteResponseCallbackHandler::Invoke,
-                                 base::Unretained(&handler)));
+                      route_response_callbacks);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, CloseRoute) {
   EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId)));
   router()->CloseRoute(kRouteId);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
@@ skipping 255 matching lines @@
   binding.reset(new mojo::Binding<interfaces::MediaRouteProvider>(
       &mock_media_route_provider, mojo::GetProxy(&media_route_provider_proxy)));
   media_router_proxy->RegisterMediaRouteProvider(
       media_route_provider_proxy.Pass(),
       base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
                  base::Unretained(&provide_handler)));
   message_loop.RunUntilIdle();
 }
 
 }  // namespace media_router