Pass origin to StartObservingMediaSinks.

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 <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 464 matching lines @@
   run_loop2.Run();
 
   issue_observer1.UnregisterObserver();
   issue_observer2.UnregisterObserver();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
   MediaSource media_source(kSource);
+  media_source.SetOrigin(kOrigin);
+  GURL origin(kOrigin);
+  MediaSource media_source2(kSource2);
 

[mark a. foltz, 2016/03/03 22:58:36]

Set an origin on media_source2?

[matt.boetger, 2016/03/04 00:22:10]

Wanted to test not setting an origin for this one.  Should default to the empty
string tested below.

   // These should only be called once even if there is more than one observer
   // for a given source.
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)));
+              StartObservingMediaSinks(mojo::String(kSource),
+                                       mojo::String(kOrigin)));
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)));
+              StartObservingMediaSinks(mojo::String(kSource2),
+                                       mojo::String("")));
 
   scoped_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source));
   EXPECT_TRUE(sinks_observer->Init());
   scoped_ptr<MockMediaSinksObserver> extra_sinks_observer(
       new MockMediaSinksObserver(router(), media_source));
   EXPECT_TRUE(extra_sinks_observer->Init());
   scoped_ptr<MockMediaSinksObserver> unrelated_sinks_observer(
-      new MockMediaSinksObserver(router(), MediaSource(kSource2)));
+      new MockMediaSinksObserver(router(), media_source2));
   EXPECT_TRUE(unrelated_sinks_observer->Init());
   ProcessEventLoop();
 
   std::vector<MediaSink> expected_sinks;
   expected_sinks.push_back(
       MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST));
   expected_sinks.push_back(
       MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST));
 
   mojo::Array<interfaces::MediaSinkPtr> mojo_sinks(2);
   mojo_sinks[0] = interfaces::MediaSink::New();
   mojo_sinks[0]->sink_id = kSinkId;
   mojo_sinks[0]->name = kSinkName;
   mojo_sinks[0]->icon_type =
       media_router::interfaces::MediaSink::IconType::CAST;
   mojo_sinks[1] = interfaces::MediaSink::New();
   mojo_sinks[1]->sink_id = kSinkId2;
   mojo_sinks[1]->name = kSinkName;
   mojo_sinks[1]->icon_type =
       media_router::interfaces::MediaSink::IconType::CAST;
 
   base::RunLoop run_loop;
-  EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks)));
+  EXPECT_CALL(*sinks_observer, OnSinksReceived(media_source,
+                                               SequenceEquals(expected_sinks)));
   EXPECT_CALL(*extra_sinks_observer,
-              OnSinksReceived(SequenceEquals(expected_sinks)))
+              OnSinksReceived(media_source, SequenceEquals(expected_sinks)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnSinksReceived(media_source.id(),
+                                       media_source.GetOrigin(),
                                        std::move(mojo_sinks));
   run_loop.Run();
 
   // Since the MediaRouterMojoImpl has already received results for
   // |media_source|, return cached results to observers that are subsequently
   // registered.
   scoped_ptr<MockMediaSinksObserver> cached_sinks_observer(
       new MockMediaSinksObserver(router(), media_source));
   EXPECT_CALL(*cached_sinks_observer,
-              OnSinksReceived(SequenceEquals(expected_sinks)));
+              OnSinksReceived(media_source, SequenceEquals(expected_sinks)));
   EXPECT_TRUE(cached_sinks_observer->Init());
 
   base::RunLoop run_loop2;
+  base::RunLoop run_loop3;

[mark a. foltz, 2016/03/03 22:58:36]

I want to clean up these test cases not to manage multiple run loops, it creates
code that is hard to maintain.

Can you try:
- Creating one run loop here
- Removing the code that calls Quit()
- Call RunUntilIdle at the end of the test to run all pending tasks

[matt.boetger, 2016/03/04 00:22:10]

Perhaps that clean up could be in a different CL since there are multiple
methods that use multiple loops in this class and that cleanup has nothing to do
with this code change.

   EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource)));
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource2)))
+              StopObservingMediaSinks(mojo::String(kSource),
+                                       mojo::String(kOrigin)))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
+  EXPECT_CALL(mock_media_route_provider_,
+              StopObservingMediaSinks(mojo::String(kSource2),
+                                       mojo::String("")))
+      .WillOnce(InvokeWithoutArgs([&run_loop3]() {
+        run_loop3.Quit();
+      }));
   sinks_observer.reset();
   extra_sinks_observer.reset();
   unrelated_sinks_observer.reset();
   cached_sinks_observer.reset();
   run_loop2.Run();
+  run_loop3.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
+  GURL origin(kOrigin);
   // When availability is UNAVAILABLE, no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::UNAVAILABLE);
   MediaSource media_source(kSource);
+  media_source.SetOrigin(kOrigin);
   scoped_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source));
-  EXPECT_CALL(*sinks_observer, OnSinksReceived(IsEmpty()));
+  EXPECT_CALL(*sinks_observer, OnSinksReceived(media_source, IsEmpty()));
   EXPECT_TRUE(sinks_observer->Init());
   MediaSource media_source2(kSource2);
+  media_source2.SetOrigin(kOrigin);
   scoped_ptr<MockMediaSinksObserver> sinks_observer2(
       new MockMediaSinksObserver(router(), media_source2));
-  EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()));
+  EXPECT_CALL(*sinks_observer2, OnSinksReceived(media_source2, IsEmpty()));
   EXPECT_TRUE(sinks_observer2->Init());
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+              StartObservingMediaSinks(mojo::String(kSource),
+                                       mojo::String(kOrigin)))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+              StartObservingMediaSinks(mojo::String(kSource2),
+                                       mojo::String(kOrigin)))
       .Times(0);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability transitions AVAILABLE, existing sink queries should be
   // sent to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+              StartObservingMediaSinks(mojo::String(kSource),
+                                       mojo::String(kOrigin)))
       .Times(1);
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+              StartObservingMediaSinks(mojo::String(kSource2),
+                                       mojo::String(kOrigin)))
       .Times(1);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // No change in availability status; no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+              StartObservingMediaSinks(mojo::String(kSource),
+                                       mojo::String(kOrigin)))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+              StartObservingMediaSinks(mojo::String(kSource2),
+                                       mojo::String(kOrigin)))
       .Times(0);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability is UNAVAILABLE, queries are already removed from MRPM.
   // Unregistering observer won't result in call to MRPM to remove query.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::UNAVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource)))
+              StopObservingMediaSinks(mojo::String(kSource),
+                                      mojo::String(kOrigin)))
       .Times(0);
   sinks_observer.reset();
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability is AVAILABLE, call is made to MRPM to remove query when
   // observer is unregistered.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource2)));
+              StopObservingMediaSinks(mojo::String(kSource2),
+                                      mojo::String(kOrigin)));
   sinks_observer2.reset();
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaRoutesObserver) {
   MockMediaRouter mock_router;
   MediaSource media_source(kSource);
   MediaSource different_media_source(kSource2);
   EXPECT_CALL(mock_media_route_provider_,
       StartObservingMediaRoutes(mojo::String(media_source.id()))).Times(2);
@@ skipping 635 matching lines @@
       .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
                         if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
                           run_loop2.Quit();
                       }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
 }
 
 }  // namespace media_router