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

chrome/browser/media/router/media_router_mojo_impl.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 "chrome/browser/media/router/media_router_mojo_impl.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/local_media_routes_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
 
 #define DLOG_WITH_INSTANCE(level) DLOG(level) << "MR #" << instance_id_ << ": "
 
 namespace media_router {
 namespace {
 
-// TODO(imcheng): We should handle failure in this case. One way is to invoke
-// all pending requests with failure. (crbug.com/490787)
-void EventPageWakeComplete(bool success) {
-  if (!success)
-    LOG(ERROR) << "An error encountered while waking the event page.";
-}
-
 scoped_ptr<content::PresentationSessionMessage>
 ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
   DCHECK(!input.is_null());
   scoped_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
     case interfaces::RouteMessage::Type::TYPE_TEXT: {
       DCHECK(!input->message.is_null());
       DCHECK(input->data.is_null());
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::TEXT));
@@ skipping 39 matching lines @@
   // |this| will be deleted in UpdateHasLocalRoute() if |has_local_route| is
   // false. Note that ObserverList supports removing an observer while
   // iterating through it.
   router_->UpdateHasLocalRoute(has_local_route);
 }
 
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
       instance_id_(base::GenerateGUID()),
-      has_local_route_(false) {
+      has_local_route_(false),
+      wakeup_attempt_count_(0),
+      weak_factory_(this) {
   DCHECK(event_page_tracker_);
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Make sure |routes_observer_| is destroyed first, because it triggers
   // additional cleanup logic in this class that depends on other fields.
   routes_observer_.reset();
 }
@@ skipping 16 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   binding_.reset(
       new mojo::Binding<interfaces::MediaRouter>(this, request.Pass()));
   binding_->set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
 
   media_route_provider_extension_id_ = extension_id;
 }
 
-// TODO(imcheng): If this occurs while there are pending requests, we should
-// probably invoke them with failure. (crbug.com/490787)
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media_route_provider_.reset();
   binding_.reset();
+
+  // If |OnConnectionError| is invoked while there are pending requests, then
+  // it means we tried to wake the extension, but weren't able to complete the
+  // connection to media route provider. Since we do not know whether the error
+  // is transient, reattempt the wakeup.
+  if (!pending_requests_.empty()) {
+    DLOG_WITH_INSTANCE(ERROR) << "A connection error while there are pending "
+                                 "requests.";
+    AttemptWakeEventPage();
+  }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRouteProvider(
     interfaces::MediaRouteProviderPtr media_route_provider_ptr,
     const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
         callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (event_page_tracker_->IsEventPageSuspended(
+          media_route_provider_extension_id_)) {
+    DVLOG_WITH_INSTANCE(1)
+        << "ExecutePendingRequests was called while extension is suspended.";
+    media_route_provider_.reset();
+    AttemptWakeEventPage();
+    return;
+  }
+
   media_route_provider_ = media_route_provider_ptr.Pass();
   media_route_provider_.set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
   callback.Run(instance_id_);
   ExecutePendingRequests();
+  wakeup_attempt_count_ = 0;
 }
 
 void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue->title;
   const Issue& issue_converted = issue.To<Issue>();
   issue_manager_.AddIssue(issue_converted);
 }
 
 void MediaRouterMojoImpl::OnSinksReceived(
@@ skipping 444 matching lines @@
   media_route_provider_->StartObservingMediaRoutes();
 }
 
 void MediaRouterMojoImpl::DoStopObservingMediaRoutes() {
   DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaRoutes";
   media_route_provider_->StopObservingMediaRoutes();
 }
 
 void MediaRouterMojoImpl::EnqueueTask(const base::Closure& closure) {
   pending_requests_.push_back(closure);
+  if (pending_requests_.size() > kMaxPendingRequests) {
+    DLOG_WITH_INSTANCE(ERROR) << "Reached max queue size. Dropping oldest "
+                              << "request.";
+    pending_requests_.pop_front();
+  }
   DVLOG_WITH_INSTANCE(2) << "EnqueueTask (queue-length="
                          << pending_requests_.size() << ")";
 }
 
 void MediaRouterMojoImpl::RunOrDefer(const base::Closure& request) {
   DCHECK(event_page_tracker_);
 
   if (media_route_provider_extension_id_.empty()) {
     DVLOG_WITH_INSTANCE(1) << "Extension ID not known yet.";
     EnqueueTask(request);
   } else if (event_page_tracker_->IsEventPageSuspended(
                  media_route_provider_extension_id_)) {
     DVLOG_WITH_INSTANCE(1) << "Waking event page.";
     EnqueueTask(request);
-    if (!event_page_tracker_->WakeEventPage(
-            media_route_provider_extension_id_,
-            base::Bind(&EventPageWakeComplete))) {
-      LOG(ERROR) << "An error encountered while waking the event page.";
-    }
+    AttemptWakeEventPage();
     media_route_provider_.reset();
   } else if (!media_route_provider_) {
     DVLOG_WITH_INSTANCE(1) << "Extension is awake, awaiting ProvideMediaRouter "
                               " to be called.";
     EnqueueTask(request);
   } else {
     request.Run();
   }
 }
 
+void MediaRouterMojoImpl::AttemptWakeEventPage() {
+  if (wakeup_attempt_count_ >= kMaxWakeupAttemptCount) {
+    DLOG_WITH_INSTANCE(ERROR) << "Attempted too many times to wake up event "
+                              << "page.";
+    DrainPendingRequests();
+    wakeup_attempt_count_ = 0;
+    return;
+  }
+
+  ++wakeup_attempt_count_;
+  DVLOG_WITH_INSTANCE(1) << "Attempting to wake up event page: attempt "
+                         << wakeup_attempt_count_;
+
+  // This return false if the extension is already awake.
+  // Callback is bound using WeakPtr because |event_page_tracker_| outlives
+  // |this|.
+  if (!event_page_tracker_->WakeEventPage(
+          media_route_provider_extension_id_,
+          base::Bind(&MediaRouterMojoImpl::EventPageWakeComplete,
+                     weak_factory_.GetWeakPtr()))) {
+    DLOG_WITH_INSTANCE(ERROR) << "Failed to schedule a wakeup for event page.";
+  }
+}
+
 void MediaRouterMojoImpl::ExecutePendingRequests() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(media_route_provider_);
   DCHECK(event_page_tracker_);
   DCHECK(!media_route_provider_extension_id_.empty());
 
-  if (event_page_tracker_->IsEventPageSuspended(
-          media_route_provider_extension_id_)) {
-    DVLOG_WITH_INSTANCE(1)
-        << "ExecutePendingRequests was called while extension is suspended.";
-    return;
-  }
-
   for (const auto& next_request : pending_requests_)
     next_request.Run();
 
   pending_requests_.clear();
 }
 
+void MediaRouterMojoImpl::EventPageWakeComplete(bool success) {
+  if (success)
+    return;
+
+  // This is likely an non-retriable error. Drop the pending requests.
+  DLOG_WITH_INSTANCE(ERROR)
+      << "An error encountered while waking the event page.";
+  DrainPendingRequests();
+}
+
+void MediaRouterMojoImpl::DrainPendingRequests() {
+  DLOG_WITH_INSTANCE(ERROR)
+      << "Draining request queue. (queue-length=" << pending_requests_.size()
+      << ")";
+  pending_requests_.clear();
+}
+
 }  // namespace media_router