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

chrome/browser/media/router/media_router_mojo_impl.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_
 
+#include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 73 matching lines @@
   }
 
   void set_instance_id_for_test(const std::string& instance_id) {
     instance_id_ = instance_id;
   }
 
  private:
   friend class MediaRouterFactory;
   friend class MediaRouterMojoExtensionTest;
   friend class MediaRouterMojoTest;
-
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest,
                            RegisterAndUnregisterMediaSinksObserver);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest,
                            RegisterMediaSinksObserverWithAvailabilityChange);
   FRIEND_TEST_ALL_PREFIXES(
       MediaRouterMojoImplTest,
       RegisterAndUnregisterMediaSinksObserverWithAvailabilityChange);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest,
                            RegisterAndUnregisterMediaRoutesObserver);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest, HandleIssue);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
                            DeferredBindingAndSuspension);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
+                           DrainPendingRequestQueue);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
+                           DropOldestPendingRequest);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
+                           AttemptedWakeupTooManyTimes);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
+                           WakeupFailedDrainsQueue);
+
+  // The max number of pending requests allowed. When number of pending requests
+  // exceeds this number, the oldest request will be dropped.
+  static const int kMaxPendingRequests = 30;
+
+  // Max consecutive attempts to wake up the component extension before
+  // giving up and draining the pending request queue.
+  static const int kMaxWakeupAttemptCount = 3;
 
   class MediaRouterMediaRoutesObserver :
       public media_router::MediaRoutesObserver {
    public:
     explicit MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router);
     ~MediaRouterMediaRoutesObserver() override;
 
     // media_router::MediaRoutesObserver:
     void OnRoutesUpdated(const std::vector<media_router::MediaRoute>& routes)
         override;
@@ skipping 33 matching lines @@
   // Enqueues a closure for later execution by ExecutePendingRequests().
   void EnqueueTask(const base::Closure& closure);
 
   // Runs a closure if the extension monitored by |extension_monitor_| is
   // active, or defers it for later execution if the extension is suspended.
   void RunOrDefer(const base::Closure& request);
 
   // Dispatches the Mojo requests queued in |pending_requests_|.
   void ExecutePendingRequests();
 
+  // Drops all pending requests. Called when we have a connection error to
+  // component extension and further reattempts are unlikely to help.
+  void DrainPendingRequests();
+
   // MediaRouter implementation.
   bool RegisterMediaSinksObserver(MediaSinksObserver* observer) override;
   void UnregisterMediaSinksObserver(MediaSinksObserver* observer) override;
   void RegisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
   void UnregisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
   void RegisterIssuesObserver(IssuesObserver* observer) override;
   void UnregisterIssuesObserver(IssuesObserver* observer) override;
   void RegisterPresentationSessionMessagesObserver(
       PresentationSessionMessagesObserver* observer) override;
   void UnregisterPresentationSessionMessagesObserver(
@@ skipping 56 matching lines @@
   // Converts the callback result of calling Mojo CreateRoute()/JoinRoute()
   // into a local callback.
   void RouteResponseReceived(
     const std::string& presentation_id,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     interfaces::MediaRoutePtr media_route,
     const mojo::String& error_text);
 
   void UpdateHasLocalRoute(bool has_local_route);
 
+  // Callback invoked by |event_page_tracker_| after an attempt to wake the
+  // component extension. If |success| is false, the pending request queue is
+  // drained.
+  void EventPageWakeComplete(bool success);
+
+  // Removes all requests from the pending requests queue. Called when there is
+  // a permanent error connecting to component extension.
+  void DrainRequestQueue();
+
+  // Calls to |event_page_tracker_| to wake the component extension.
+  // |media_route_provider_extension_id_| must not be empty and the extension
+  // should be currently suspended.
+  // If there have already been too many wakeup attempts, give up and drain
+  // the pending request queue.
+  void AttemptWakeEventPage();
+
   // Pending requests queued to be executed once component extension
   // becomes ready.
-  std::vector<base::Closure> pending_requests_;
+  std::deque<base::Closure> pending_requests_;
 
   base::ScopedPtrHashMap<MediaSource::Id, scoped_ptr<MediaSinksQuery>>
       sinks_queries_;
 
   base::ObserverList<LocalMediaRoutesObserver> local_routes_observers_;
 
   base::ObserverList<MediaRoutesObserver> routes_observers_;
 
   using PresentationSessionMessagesObserverList =
       base::ObserverList<PresentationSessionMessagesObserver>;
@@ skipping 35 matching lines @@
   // Set to true if there are routes started on this instance.
   bool has_local_route_;
 
   // Observes local routes in order to notify LocalMediaRoutesObservers when
   // there are no more local routes.
   scoped_ptr<MediaRoutesObserver> routes_observer_;
 
   // The last reported sink availability from the media route provider manager.
   interfaces::MediaRouter::SinkAvailability availability_;
 
+  int wakeup_attempt_count_;
+
   base::ThreadChecker thread_checker_;
 
+  base::WeakPtrFactory<MediaRouterMojoImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_