[Media Router] Connection reattempt logic and bound pending request queue size.

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 757 matching lines @@
     process_manager_ = static_cast<TestProcessManager*>(
         extensions::ProcessManager::Get(profile_.get()));
     DCHECK(process_manager_);
 
     // Create MR and its proxy, so that it can be accessed through Mojo.
     media_router_.reset(new MediaRouterMojoImpl(process_manager_));
     ProcessEventLoop();
   }
 
   void TearDown() override {
+    media_router_.reset();
     profile_.reset();
     // Explicitly delete the TestingBrowserProcess before |message_loop_|.
     // This allows it to do cleanup before |message_loop_| goes away.
     TestingBrowserProcess::DeleteInstance();
   }
 
   // Constructs bindings so that |media_router_| delegates calls to
   // |mojo_media_router_|, which are then handled by
   // |mock_media_route_provider_service_|.
   void BindMediaRouteProvider() {
@@ skipping 68 matching lines @@
   // The queued CloseRoute(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)));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 }
 
+TEST_F(MediaRouterMojoExtensionTest, AttemptedWakeupTooManyTimes) {
+  BindMediaRouteProvider();
+
+  // CloseRoute 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);
+  EXPECT_EQ(1u, media_router_->pending_requests_.size());
+
+  // 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());
+
+  // 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);
+  EXPECT_EQ(1u, media_router_->pending_requests_.size());
+}
+
+TEST_F(MediaRouterMojoExtensionTest, WakeupFailedDrainsQueue) {
+  BindMediaRouteProvider();
+
+  // CloseRoute 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);
+  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);
+  EXPECT_EQ(1u, media_router_->pending_requests_.size());
+}
+
+TEST_F(MediaRouterMojoExtensionTest, DropOldestPendingRequest) {
+  const size_t kMaxPendingRequests = MediaRouterMojoImpl::kMaxPendingRequests;
+
+  // Request is queued.
+  media_router_->CloseRoute(kRouteId);
+  EXPECT_EQ(1u, media_router_->pending_requests_.size());
+
+  for (size_t i = 0; i < kMaxPendingRequests; ++i)
+    media_router_->CloseRoute(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.
+  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)))
+      .Times(kMaxPendingRequests);
+  RegisterMediaRouteProvider();
+  ProcessEventLoop();
+}
+
 }  // namespace media_router