[Media Router] Sync state when MR extension is (re)connected to MR.

chrome/browser/media/router/mojo/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 <memory>
 #include <string>
 #include <utility>
@@ skipping 1045 matching lines @@
     EXPECT_EQ(UINT8_C(2), messages_[4].binary->front());
     EXPECT_EQ(RouteMessage::BINARY, messages_[5].type);
     ASSERT_TRUE(messages_[5].binary);
     ASSERT_EQ(1u, messages_[5].binary->size());
     EXPECT_EQ(UINT8_C(3), messages_[5].binary->front());
   }
 
   std::vector<RouteMessage> messages_;
 };
 
+class NoopMessageObserver : public RouteMessageObserver {

[mark a. foltz, 2017/05/03 17:37:08]

s/Noop/Fake/ (or maybe s/Noop/Null/) to follow the usual terminology.

http://stackoverflow.com/questions/346372/whats-the-difference-between-faking...

[imcheng, 2017/05/03 18:22:41]

Done.

+ public:
+  NoopMessageObserver(MediaRouter* router, const MediaRoute::Id& route_id)
+      : RouteMessageObserver(router, route_id) {}
+  ~NoopMessageObserver() final {}
+
+  void OnMessagesReceived(const std::vector<RouteMessage>& messages) final {}
+};
+
 }  // namespace
 
 TEST_F(MediaRouterMojoImplTest, RouteMessagesSingleObserver) {
   std::vector<RouteMessage> incoming_batch1, incoming_batch2, incoming_batch3;
   PopulateRouteMessages(&incoming_batch1, &incoming_batch2, &incoming_batch3);
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   EXPECT_CALL(mock_media_route_provider_,
               StartListeningForRouteMessages(Eq(expected_route_id)))
@@ skipping 384 matching lines @@
                                         expected_count);
   }
 
   void ExpectWakeupBucketCount(MediaRouteProviderWakeup wakeup,
                                int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Wakeup",
                                         static_cast<int>(wakeup),
                                         expected_count);
   }
 
+  MediaRouterMojoImpl* router() const { return media_router_.get(); }
+
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<MediaRouterMojoImpl> media_router_;
   RegisterMediaRouteProviderHandler provide_handler_;
   TestProcessManager* process_manager_;
   testing::StrictMock<MockMediaRouteProvider> mock_media_route_provider_;
   mojom::MediaRouterPtr media_router_proxy_;
   scoped_refptr<extensions::Extension> extension_;
 
  private:
   std::unique_ptr<TestingProfile> profile_;
@@ skipping 183 matching lines @@
   base::RunLoop run_loop2;
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
       .WillOnce(InvokeWithoutArgs([&run_loop]() {
                   run_loop.Quit();
                 }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false)).WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .Times(2);
-  // EnableMdnsDisocvery() is never called except on Windows.
+  // EnableMdnsDiscovery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
                   run_loop2.Quit();
                 }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
   // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
   media_router_->OnUserGesture();
   base::RunLoop run_loop3;
@@ skipping 20 matching lines @@
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
       .WillOnce(InvokeWithoutArgs([&run_loop5]() {
                   run_loop5.Quit();
                 }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false)).WillOnce(Return(false));
   // Expected because it was used to wake up the page.
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId));
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()));
-  // EnableMdnsDisocvery() is never called except on Windows.
+  // EnableMdnsDiscovery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop6]() {
                   run_loop6.Quit();
                 }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop5.Run();
   run_loop6.Run();
   // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
   media_router_->OnUserGesture();
@@ skipping 33 matching lines @@
 #endif
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
+TEST_F(MediaRouterMojoExtensionTest, SyncStateToMediaRouteProvider) {
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
+      .WillRepeatedly(Return(false));
+  MediaSource media_source = MediaSource(kSource);
+  std::unique_ptr<MockMediaSinksObserver> sinks_observer;
+  std::unique_ptr<MockMediaRoutesObserver> routes_observer;
+  std::unique_ptr<NoopMessageObserver> messages_observer;
+
+  {
+    EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
+    BindMediaRouteProvider();
+    RegisterMediaRouteProvider();
+    base::RunLoop().RunUntilIdle();
+    EXPECT_TRUE(Mock::VerifyAndClearExpectations(&provide_handler_));
+  }
+
+  {
+    media_router_->OnSinkAvailabilityUpdated(
+        mojom::MediaRouter::SinkAvailability::PER_SOURCE);
+    EXPECT_CALL(mock_media_route_provider_,
+                StartObservingMediaSinks(media_source.id()));
+    sinks_observer.reset(new MockMediaSinksObserver(
+        router(), media_source, url::Origin(GURL(kOrigin))));
+    EXPECT_TRUE(sinks_observer->Init());
+
+    EXPECT_CALL(mock_media_route_provider_,
+                StartObservingMediaRoutes(media_source.id()));
+    routes_observer.reset(
+        new MockMediaRoutesObserver(router(), media_source.id()));
+
+    EXPECT_CALL(mock_media_route_provider_,
+                StartListeningForRouteMessages(media_source.id()));
+    messages_observer.reset(
+        new NoopMessageObserver(router(), media_source.id()));
+    base::RunLoop().RunUntilIdle();
+    EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
+  }
+
+  {
+    EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
+    EXPECT_CALL(mock_media_route_provider_,
+                StartObservingMediaSinks(media_source.id()));
+    EXPECT_CALL(mock_media_route_provider_,
+                StartObservingMediaRoutes(media_source.id()));
+    EXPECT_CALL(mock_media_route_provider_,
+                StartListeningForRouteMessages(media_source.id()));
+    media_router_->OnConnectionError();
+    BindMediaRouteProvider();
+    RegisterMediaRouteProvider();
+    base::RunLoop().RunUntilIdle();
+  }
+}
+
 }  // namespace media_router