[Media Router] Add a presentation id to MediaRoute mapping in the MR

chrome/browser/media/router/media_router_base.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_base.h"
 
+#include <map>
+
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace media_router {
 
@@ skipping 14 matching lines @@
     incognito_route_ids.clear();
     // TODO(crbug.com/611486): Have the MRPM pass a list of joinable route ids
     // via |joinable_route_ids|, and check here if it is non-empty.
     has_route = !routes.empty();
     for (const auto& route : routes) {
       if (route.is_incognito())
         incognito_route_ids.push_back(route.media_route_id());
     }
   }
 
+  void RegisterPresentationRoute(const std::string& presentation_id,
+                                 const MediaRoute& route) {
+    presentation_id_route.insert(std::make_pair(presentation_id, route));
+  }
+
+  void UnregisterPresentationRoute(const std::string& presentation_id) {
+    presentation_id_route.erase(presentation_id);

[imcheng, 2017/03/08 20:06:35]

If a MediaRoute was removed by the MRP, how is the associated entry removed from
the map?

[mark a. foltz, 2017/03/08 22:01:47]

One solution would be for each update sent to the internal routes observer would
check if a newly-removed route was in the map, and remove it.

If we went with keeping the id in the route, then you would only need to have
add the Get() method to iterate through the routes in the internal observer and
find the matching route.

[zhaobin, 2017/03/09 00:34:27]

Done.

+  }
+
+  const MediaRoute* GetPresentationRoute(
+      const std::string& presentation_id) const {
+    auto it = presentation_id_route.find(presentation_id);
+    if (it == presentation_id_route.end())
+      return nullptr;
+
+    return &it->second;
+  }
+
   bool has_route;
   std::vector<MediaRoute> current_routes;
   std::vector<MediaRoute::Id> incognito_route_ids;
+  std::map<std::string, MediaRoute> presentation_id_route;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InternalMediaRoutesObserver);
 };
 
 MediaRouterBase::~MediaRouterBase() {
   CHECK(!internal_routes_observer_);
 }
 
 std::unique_ptr<PresentationConnectionStateSubscription>
@@ skipping 15 matching lines @@
 
 void MediaRouterBase::OnIncognitoProfileShutdown() {
   for (const auto& route_id : internal_routes_observer_->incognito_route_ids)
     TerminateRoute(route_id);
 }
 
 std::vector<MediaRoute> MediaRouterBase::GetCurrentRoutes() const {
   return internal_routes_observer_->current_routes;
 }
 
+void MediaRouterBase::RegisterPresentationRoute(
+    const std::string& presentation_id,
+    const MediaRoute& route) {
+  DCHECK(internal_routes_observer_);
+  internal_routes_observer_->RegisterPresentationRoute(presentation_id, route);
+}
+
+void MediaRouterBase::UnregisterPresentationRoute(
+    const std::string& presentation_id) {
+  DCHECK(internal_routes_observer_);
+  internal_routes_observer_->UnregisterPresentationRoute(presentation_id);
+}
+
+const MediaRoute* MediaRouterBase::GetPresentationRoute(
+    const std::string& presentation_id) const {
+  DCHECK(internal_routes_observer_);
+  return internal_routes_observer_->GetPresentationRoute(presentation_id);
+}
+
 MediaRouterBase::MediaRouterBase() : initialized_(false) {}
 
 // static
 std::string MediaRouterBase::CreatePresentationId() {
   return "mr_" + base::GenerateGUID();
 }
 
 void MediaRouterBase::NotifyPresentationConnectionStateChange(
     const MediaRoute::Id& route_id,
     content::PresentationConnectionState state) {
@@ skipping 43 matching lines @@
   }
 }
 
 void MediaRouterBase::Shutdown() {
   // The observer calls virtual methods on MediaRouter; it must be destroyed
   // outside of the dtor
   internal_routes_observer_.reset();
 }
 
 }  // namespace media_router