[Media Router] Erase PresentationFrame entry when corresponding RenderFrameHost is gone

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 <unordered_map>
 #include <utility>
 #include <vector>
@@ skipping 104 matching lines @@
   const content::PresentationConnectionMessageCallback message_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationSessionMessagesObserver);
 };
 
 }  // namespace
 
 // Used by PresentationServiceDelegateImpl to manage
 // listeners and default presentation info in a render frame.
 // Its lifetime:
-//  * PresentationFrameManager AddDelegateObserver
-//  * Reset 0+ times.
-//  * PresentationFrameManager.RemoveDelegateObserver.
+//  * Create an instance with |render_frame_host_id_| if no instance with the
+//    same |render_frame_host_id_| exists in:
+//      PresentationFrameManager::OnPresentationSessionStarted
+//      PresentationFrameManager::OnDefaultPresentationSessionStarted
+//      PresentationFrameManager::SetScreenAvailabilityListener
+//  * Destroy the instance in:
+//      PresentationFrameManager::Reset
 class PresentationFrame {
  public:
   PresentationFrame(const RenderFrameHostId& render_frame_host_id,
                     content::WebContents* web_contents,
                     MediaRouter* router);
   ~PresentationFrame();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
@@ skipping 15 matching lines @@
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
       const MediaRoute& route);
   void OnPresentationServiceDelegateDestroyed() const;
 
-  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_;
   base::SmallMap<
       std::map<std::string, std::unique_ptr<PresentationMediaSinksObserver>>>
       url_to_sinks_observer_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationSessionMessagesObserver>>
       session_messages_observers_;
 
   RenderFrameHostId render_frame_host_id_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   content::WebContents* web_contents_;
   MediaRouter* router_;
-
-  DelegateObserver* delegate_observer_;
 };
 
 PresentationFrame::PresentationFrame(
     const RenderFrameHostId& render_frame_host_id,
     content::WebContents* web_contents,
     MediaRouter* router)
     : render_frame_host_id_(render_frame_host_id),
       web_contents_(web_contents),
       router_(router) {
   DCHECK(web_contents_);
@@ skipping 261 matching lines @@
     const content::PresentationSessionInfo& session,
     const MediaRoute& route) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->OnPresentationSessionStarted(session, route);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
     const PresentationRequest& request,
     const content::PresentationSessionInfo& session,
     const MediaRoute& route) {
-  const auto it = presentation_frames_.find(request.render_frame_host_id());
-  if (it != presentation_frames_.end())
-    it->second->OnPresentationSessionStarted(session, route);
+  OnPresentationSessionStarted(request.render_frame_host_id(), session, route);
 
   if (default_presentation_request_ &&
       default_presentation_request_->Equals(request)) {
     default_presentation_started_callback_.Run(session);
   }
 }
 
 const MediaRoute::Id PresentationFrameManager::GetRouteId(
     const RenderFrameHostId& render_frame_host_id,
     const std::string& presentation_id) const {
@@ skipping 85 matching lines @@
 
 void PresentationFrameManager::RemoveDefaultPresentationRequestObserver(
     PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
         observer) {
   default_presentation_request_observers_.RemoveObserver(observer);
 }
 
 void PresentationFrameManager::Reset(
     const RenderFrameHostId& render_frame_host_id) {
   const auto it = presentation_frames_.find(render_frame_host_id);
-  if (it != presentation_frames_.end())
+  if (it != presentation_frames_.end()) {
     it->second->Reset();
+    presentation_frames_.erase(it);
+  }
 
   if (default_presentation_request_ &&
       render_frame_host_id ==
           default_presentation_request_->render_frame_host_id()) {
     ClearDefaultPresentationRequest();
   }
 }
 
 void PresentationFrameManager::RemoveConnection(
     const RenderFrameHostId& render_frame_host_id,
@@ skipping 396 matching lines @@
   const base::ListValue* origins =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext())
           ->GetPrefs()
           ->GetList(prefs::kMediaRouterTabMirroringSources);
   return origins &&
          origins->Find(base::StringValue(origin.Serialize())) != origins->end();
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router