Added support for multiple sink observers per frame.

chrome/browser/media/router/presentation_service_delegate_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/presentation_service_delegate_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 89 matching lines @@
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
-  scoped_ptr<PresentationMediaSinksObserver> sinks_observer_;
+  std::map<std::string, scoped_ptr<PresentationMediaSinksObserver>>
+      url_to_sinks_observer_;
   base::ScopedPtrHashMap<MediaRoute::Id,
                          scoped_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   ScopedVector<PresentationSessionMessagesObserver> session_messages_observers_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   const content::WebContents* web_contents_;
   MediaRouter* router_;
 
   DelegateObserver* delegate_observer_;
@@ skipping 30 matching lines @@
 
 const std::vector<MediaRoute::Id> PresentationFrame::GetRouteIds() const {
   std::vector<MediaRoute::Id> route_ids;
   for (const auto& e : presentation_id_to_route_id_)
     route_ids.push_back(e.second);
   return route_ids;
 }
 
 bool PresentationFrame::SetScreenAvailabilityListener(
     content::PresentationScreenAvailabilityListener* listener) {
-  if (sinks_observer_ && sinks_observer_->listener() == listener)
+  MediaSource source(GetMediaSourceFromListener(listener));
+  auto& sinks_observer = url_to_sinks_observer_[source.id()];
+  if (sinks_observer && sinks_observer->listener() == listener)
     return false;
 
-  MediaSource source(GetMediaSourceFromListener(listener));
-  sinks_observer_.reset(
+  sinks_observer.reset(
       new PresentationMediaSinksObserver(router_, listener, source));
 
-  if (!sinks_observer_->Init()) {
-    sinks_observer_.reset();
+  if (!sinks_observer->Init()) {
+    url_to_sinks_observer_.erase(source.id());
     listener->OnScreenAvailabilityNotSupported();
     return false;
   }
 
   return true;
 }
 
 bool PresentationFrame::RemoveScreenAvailabilityListener(
     content::PresentationScreenAvailabilityListener* listener) {
-  if (sinks_observer_ && sinks_observer_->listener() == listener) {
-    sinks_observer_.reset();
+  MediaSource source(GetMediaSourceFromListener(listener));
+  auto sinks_observer_it = url_to_sinks_observer_.find(source.id());
+  if (sinks_observer_it != url_to_sinks_observer_.end() &&
+      sinks_observer_it->second->listener() == listener) {
+    url_to_sinks_observer_.erase(sinks_observer_it);
     return true;
   }
   return false;
 }
 
 bool PresentationFrame::HasScreenAvailabilityListenerForTest(
     const MediaSource::Id& source_id) const {
-  return sinks_observer_ && sinks_observer_->source().id() == source_id;
+  return url_to_sinks_observer_.find(source_id) != url_to_sinks_observer_.end();
 }
 
 void PresentationFrame::Reset() {
   for (const auto& pid_route_id : presentation_id_to_route_id_)
     router_->DetachRoute(pid_route_id.second);
 
   presentation_id_to_route_id_.clear();
-  sinks_observer_.reset();
+  url_to_sinks_observer_.clear();
   connection_state_subscriptions_.clear();
   session_messages_observers_.clear();
 }
 
 void PresentationFrame::RemoveConnection(const std::string& presentation_id,
                                          const MediaRoute::Id& route_id) {
   // Remove the presentation id mapping so a later call to Reset is a no-op.
   presentation_id_to_route_id_.erase(presentation_id);
 
   // We no longer need to observe route messages.
@@ skipping 668 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router