[MediaRouter] Renames CloseRoute() to Terminate() and creates DetachRoute()

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 271 matching lines @@
   RouteResponseCallbackHandler handler;
   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), nullptr,
                       route_response_callbacks);
   ProcessEventLoop();
 }
 
-TEST_F(MediaRouterMojoImplTest, CloseRoute) {
-  EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId)));
-  router()->CloseRoute(kRouteId);
+TEST_F(MediaRouterMojoImplTest, DetachRoute) {
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
+  router()->DetachRoute(kRouteId);
   ProcessEventLoop();
 }
 
+TEST_F(MediaRouterMojoImplTest, TerminateRoute) {
+  EXPECT_CALL(mock_media_route_provider_,
+              TerminateRoute(mojo::String(kRouteId)));
+  router()->TerminateRoute(kRouteId);
+  ProcessEventLoop();
+}
+
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
   issue_observer1.RegisterObserver();
   issue_observer2.RegisterObserver();
 
   interfaces::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
   const Issue& expected_issue1 = mojo_issue1.To<Issue>();
 
   const Issue* issue;
@@ skipping 524 matching lines @@
   EXPECT_TRUE(router()->HasLocalDisplayRoute());
 }
 
 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
       .Times(2)
       .WillRepeatedly(Return(true));
-  router()->CloseRoute(kRouteId);
-  router()->CloseRoute(kRouteId2);
+  router()->DetachRoute(kRouteId);
+  router()->DetachRoute(kRouteId2);
   ProcessEventLoop();
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(1)
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId)));
-  EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId2)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)));
   ConnectProviderManagerService();
   ProcessEventLoop();
 }
 
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest()
     : process_manager_(nullptr),
       message_loop_(mojo::common::MessagePumpMojo::Create())
   {}
@@ skipping 68 matching lines @@
   scoped_ptr<TestingProfile> profile_;
   base::MessageLoop message_loop_;
   interfaces::MediaRouteProviderPtr media_route_provider_proxy_;
   scoped_ptr<mojo::Binding<interfaces::MediaRouteProvider>> binding_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoExtensionTest);
 };
 
 TEST_F(MediaRouterMojoExtensionTest, DeferredBindingAndSuspension) {
-  // CloseRoute is called before *any* extension has connected.
+  // DetachRoute is called before *any* extension has connected.
   // It should be queued.
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
 
   BindMediaRouteProvider();
 
   // |mojo_media_router| signals its readiness to the MR by registering
   // itself via RegisterMediaRouteProvider().
   // Now that the |media_router| and |mojo_media_router| are fully initialized,
-  // the queued CloseRoute() call should be executed.
+  // the queued DetachRoute() call should be executed.
   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(kRouteId)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 
   // Extension is suspended and re-awoken.
   ResetMediaRouteProvider();
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->CloseRoute(kRouteId2);
+  media_router_->DetachRoute(kRouteId2);
   ProcessEventLoop();
 
   // RegisterMediaRouteProvider() is called.
-  // The queued CloseRoute(kRouteId2) call should be executed.
+  // The queued DetachRoute(kRouteId2) call should be executed.
   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)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   ProcessEventLoop();
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CLOSE_ROUTE, 1);
+  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
 }
 
 TEST_F(MediaRouterMojoExtensionTest, AttemptedWakeupTooManyTimes) {
   BindMediaRouteProvider();
 
-  // CloseRoute is called while extension is suspended. It should be queued.
+  // DetachRoute is called while extension is suspended. It should be queued.
   // Schedule a component extension wakeup.
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CLOSE_ROUTE, 1);
+  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
 
   // Media route provider fails to connect to media router before extension is
   // suspended again, and |OnConnectionError| is invoked. Retry the wakeup.
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .Times(MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1)
       .WillRepeatedly(
           testing::DoAll(media::RunCallback<1>(true), Return(true)));
   for (int i = 0; i < MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1; ++i)
     media_router_->OnConnectionError();
 
   // We have already tried |kMaxWakeupAttemptCount| times. If we get an error
   // again, we will give up and the pending request queue will be drained.
   media_router_->OnConnectionError();
   EXPECT_TRUE(media_router_->pending_requests_.empty());
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CONNECTION_ERROR,
                               MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1);
 
   // Requests that comes in after queue is drained should be queued.
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
 }
 
 TEST_F(MediaRouterMojoExtensionTest, WakeupFailedDrainsQueue) {
   BindMediaRouteProvider();
 
-  // CloseRoute is called while extension is suspended. It should be queued.
+  // DetachRoute is called while extension is suspended. It should be queued.
   // Schedule a component extension wakeup.
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   base::Callback<void(bool)> extension_wakeup_callback;
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .WillOnce(
           testing::DoAll(SaveArg<1>(&extension_wakeup_callback), Return(true)));
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
 
   // Extension wakeup callback returning false is an non-retryable error.
   // Queue should be drained.
   extension_wakeup_callback.Run(false);
   EXPECT_TRUE(media_router_->pending_requests_.empty());
 
   // Requests that comes in after queue is drained should be queued.
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CLOSE_ROUTE, 1);
+  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
 }
 
 TEST_F(MediaRouterMojoExtensionTest, DropOldestPendingRequest) {
   const size_t kMaxPendingRequests = MediaRouterMojoImpl::kMaxPendingRequests;
 
   // Request is queued.
-  media_router_->CloseRoute(kRouteId);
+  media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
 
   for (size_t i = 0; i < kMaxPendingRequests; ++i)
-    media_router_->CloseRoute(kRouteId2);
+    media_router_->DetachRoute(kRouteId2);
 
   // The request queue size should not exceed |kMaxPendingRequests|.
   EXPECT_EQ(kMaxPendingRequests, media_router_->pending_requests_.size());
 
   // The oldest request should have been dropped, so we don't expect to see
-  // CloseRoute(kRouteId) here.
+  // DetachRoute(kRouteId) here.
   BindMediaRouteProvider();
   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)))
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests);
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 }
 
 }  // namespace media_router