[Media Router] Replace route messaging API.

chrome/browser/media/router/mojo/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/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 580 matching lines @@
   if (!observer_list) {
     observer_list = new base::ObserverList<PresentationSessionMessagesObserver>;
     messages_observers_.add(route_id, base::WrapUnique(observer_list));
   } else {
     DCHECK(!observer_list->HasObserver(observer));
   }
 
   bool should_listen = !observer_list->might_have_observers();
   observer_list->AddObserver(observer);
   if (should_listen) {
-    RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoListenForRouteMessages,
-                          base::Unretained(this), route_id));
+    SetWakeReason(
+        MediaRouteProviderWakeReason::START_LISTENING_FOR_ROUTE_MESSAGES);
+    RunOrDefer(
+        base::Bind(&MediaRouterMojoImpl::DoStartListeningForRouteMessages,
+                   base::Unretained(this), route_id));
   }
 }
 
 void MediaRouterMojoImpl::UnregisterPresentationSessionMessagesObserver(
     PresentationSessionMessagesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
 
   const MediaRoute::Id& route_id = observer->route_id();
   auto* observer_list = messages_observers_.get(route_id);
@@ skipping 92 matching lines @@
     const MediaRoute::Id& route_id,
     std::unique_ptr<std::vector<uint8_t>> data,
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteBinaryMessage " << route_id;
   mojo::Array<uint8_t> mojo_array;
   mojo_array.Swap(data.get());
   media_route_provider_->SendRouteBinaryMessage(route_id, std::move(mojo_array),
                                                 callback);
 }
 
-void MediaRouterMojoImpl::DoListenForRouteMessages(
+void MediaRouterMojoImpl::DoStartListeningForRouteMessages(
     const MediaRoute::Id& route_id) {
-  DVLOG_WITH_INSTANCE(1) << "ListenForRouteMessages";
-  if (!ContainsValue(route_ids_listening_for_messages_, route_id)) {
-    route_ids_listening_for_messages_.insert(route_id);
-    media_route_provider_->ListenForRouteMessages(
-        route_id, base::Bind(&MediaRouterMojoImpl::OnRouteMessagesReceived,
-                             base::Unretained(this), route_id));
-  }
+  DVLOG_WITH_INSTANCE(1) << "DoStartListeningForRouteMessages";
+  media_route_provider_->StartListeningForRouteMessages(route_id);
 }
 
 void MediaRouterMojoImpl::DoStopListeningForRouteMessages(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "StopListeningForRouteMessages";
-
-  // No need to erase |route_ids_listening_for_messages_| entry here.
-  // It will be removed when there are no more observers by the time
-  // |OnRouteMessagesReceived| is invoked.
   media_route_provider_->StopListeningForRouteMessages(route_id);
 }
 
 void MediaRouterMojoImpl::DoSearchSinks(
     const MediaSink::Id& sink_id,
     const MediaSource::Id& source_id,
     const std::string& search_input,
     const std::string& domain,
     const MediaSinkSearchResponseCallback& sink_callback) {
   DVLOG_WITH_INSTANCE(1) << "SearchSinks";
   auto sink_search_criteria = interfaces::SinkSearchCriteria::New();
   sink_search_criteria->input = search_input;
   sink_search_criteria->domain = domain;
   media_route_provider_->SearchSinks(
       sink_id, source_id, std::move(sink_search_criteria),
       base::Bind(&ForwardSinkSearchCallback, sink_callback));
 }
 
 void MediaRouterMojoImpl::OnRouteMessagesReceived(
-    const MediaRoute::Id& route_id,
-    mojo::Array<interfaces::RouteMessagePtr> messages,
-    bool error) {
-  DVLOG(1) << "OnRouteMessagesReceived";
+    const mojo::String& route_id,
+    mojo::Array<interfaces::RouteMessagePtr> messages) {
+  DVLOG_WITH_INSTANCE(1) << "OnRouteMessagesReceived";
 
-  // If |messages| is null, then no more messages will come from this route.
-  // We can stop listening.
-  if (error) {
-    DVLOG(2) << "Encountered error in OnRouteMessagesReceived for " << route_id;
-    route_ids_listening_for_messages_.erase(route_id);
+  DCHECK(!messages.storage().empty());
+
+  auto* observer_list = messages_observers_.get(route_id);
+  if (!observer_list) {
     return;
   }
 
-  // Check if there are any observers remaining. If not, the messages
-  // can be discarded and we can stop listening for the next batch of messages.
-  auto* observer_list = messages_observers_.get(route_id);
-  if (!observer_list) {
-    route_ids_listening_for_messages_.erase(route_id);
-    return;
+  ScopedVector<content::PresentationSessionMessage> session_messages;
+  session_messages.reserve(messages.size());
+  for (size_t i = 0; i < messages.size(); ++i) {
+    session_messages.push_back(
+        ConvertToPresentationSessionMessage(std::move(messages[i])));
   }
-
-  // If |messages| is empty, then |StopListeningForRouteMessages| was invoked
-  // but we have added back an observer since. Keep listening for more messages,
-  // but do not notify observers with empty list.
-  if (!messages.storage().empty()) {
-    ScopedVector<content::PresentationSessionMessage> session_messages;
-    session_messages.reserve(messages.size());
-    for (size_t i = 0; i < messages.size(); ++i) {
-      session_messages.push_back(
-          ConvertToPresentationSessionMessage(std::move(messages[i])));
-    }
-    base::ObserverList<PresentationSessionMessagesObserver>::Iterator
-        observer_it(observer_list);
-    bool single_observer =
-        observer_it.GetNext() != nullptr && observer_it.GetNext() == nullptr;
-    FOR_EACH_OBSERVER(PresentationSessionMessagesObserver, *observer_list,
-                      OnMessagesReceived(session_messages, single_observer));
-  }
-
-  // Listen for more messages.
-  media_route_provider_->ListenForRouteMessages(
-      route_id, base::Bind(&MediaRouterMojoImpl::OnRouteMessagesReceived,
-                           base::Unretained(this), route_id));
+  base::ObserverList<PresentationSessionMessagesObserver>::Iterator observer_it(
+      observer_list);
+  bool single_observer =
+      observer_it.GetNext() != nullptr && observer_it.GetNext() == nullptr;
+  FOR_EACH_OBSERVER(PresentationSessionMessagesObserver, *observer_list,
+                    OnMessagesReceived(session_messages, single_observer));
 }
 
 void MediaRouterMojoImpl::OnSinkAvailabilityUpdated(
     SinkAvailability availability) {
   if (availability_ == availability)
     return;
 
   availability_ = availability;
   if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
     // Sinks are no longer available. MRPM has already removed all sink queries.
@@ skipping 234 matching lines @@
                         base::Unretained(this), source_id));
 }
 
 void MediaRouterMojoImpl::DoUpdateMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoUpdateMediaSinks" << source_id;
   media_route_provider_->UpdateMediaSinks(source_id);
 }
 
 }  // namespace media_router