[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 578 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(thread_checker_.CalledOnValidThread());
   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;

[dcheng, 2016/07/18 16:14:34]

This is... not nice.

1) //content/browser/presentation is also using legacy type converters, which
need to be migrated.
2) If it's important not to repeat work, we should just do the conversion once
anyway.

Also, can we just have RouteMesage or SessionMessage instead of having both?
They're already very similar.

[imcheng, 2016/07/18 18:56:41]

The message type enum on the two definitions are slightly different. Binary
messages are represented in two types (ARRAY_BUFFER and BLOB) in SessionMessage,
versus just one in RouteMessage. Although I don't see places where ARRAY_BUFFER
and BLOB are treated differently - will need to follow up with avayvod@ /
mlamouri@ on that.

+  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