Non-Local Join for Media Router and Presentation API

chrome/browser/media/android/router/media_router_android.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/android/router/media_router_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/guid.h"
@@ skipping 86 matching lines @@
       env,
       java_media_router_.obj(),
       jsource_id.obj(),
       jsink_id.obj(),
       jpresentation_id.obj(),
       jorigin.obj(),
       tab_id,
       route_request_id);
 }
 
+void MediaRouterAndroid::JoinRouteByRouteId(
+    const MediaSource::Id& source,
+    const MediaRoute::Id& route_id,
+    const GURL& origin,
+    content::WebContents* web_contents,
+    const std::vector<MediaRouteResponseCallback>& callbacks) {
+  NOTIMPLEMENTED();
+}
+
 void MediaRouterAndroid::JoinRoute(
     const MediaSource::Id& source_id,
     const std::string& presentation_id,
     const GURL& origin,
     content::WebContents* web_contents,
     const std::vector<MediaRouteResponseCallback>& callbacks) {
   if (!origin.is_valid()) {
     for (const MediaRouteResponseCallback& callback : callbacks)
       callback.Run(nullptr, "", "Invalid origin");
     return;
@@ skipping 135 matching lines @@
     ScopedJavaLocalRef<jstring> jsource_id =
         base::android::ConvertUTF8ToJavaString(env, source_id);
     Java_ChromeMediaRouter_stopObservingMediaSinks(
         env, java_media_router_.obj(), jsource_id.obj());
   }
 }
 
 void MediaRouterAndroid::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DVLOG(2) << "Added MediaRoutesObserver: " << observer;
-  routes_observers_.AddObserver(observer);
+  const std::string& source_id = observer->source_id();
+  base::ObserverList<MediaRoutesObserver>* observer_list =

[imcheng, 2015/11/26 00:49:45]

Use auto* so it's consistent with below.

[matt.boetger, 2015/12/01 01:26:55]

Reverting.

+      routes_observers_.get(source_id);
+  if (!observer_list) {

[imcheng, 2015/11/26 00:49:45]

It looks like we don't currently support joinable routes in the android
implementation because the implementation to notify observers of joinable routes
below is incorrect. There's also no need to support joinable routes on android.

I would suggest reverting the change here and then add something like:

if (!source_id.empty())
  NOTIMPLEMENTED() << "Joinable routes query not implemented."

[whywhat, 2015/11/26 14:43:04]

So actually, on Android it doesn't seem like we can identify running sessions
although we can try to join each device with a particular application id and if
it succeeds it means the route was joinable :)

By default, however, the Android SDK tries to join the application if it's
running, so we could at least tell the MR if the new route was a fresh session
or if it joined an already running application. Not sure if it's something MR
needs though.

[matt.boetger, 2015/12/01 01:26:55]

Done.

[matt.boetger, 2015/12/01 01:26:55]

Done.

+    observer_list = new base::ObserverList<MediaRoutesObserver>;
+    routes_observers_.add(source_id, make_scoped_ptr(observer_list));
+  } else {
+    DCHECK(!observer_list->HasObserver(observer));
+  }
+  observer_list->AddObserver(observer);
 }
 
 void MediaRouterAndroid::UnregisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
-  if (!routes_observers_.HasObserver(observer))
+  const std::string& source_id = observer->source_id();
+  auto* observer_list = routes_observers_.get(source_id);
+  if (!observer_list || !observer_list->HasObserver(observer))
     return;
-  routes_observers_.RemoveObserver(observer);
+
+  observer_list->RemoveObserver(observer);
 }
 
 void MediaRouterAndroid::RegisterIssuesObserver(IssuesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void MediaRouterAndroid::UnregisterIssuesObserver(IssuesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
@@ skipping 76 matching lines @@
                    ConvertJavaStringToUTF8(env, jsink_id), std::string(),
                    jis_local, std::string(),
                    true);  // TODO(avayvod): Populate for_display.
 
   for (const MediaRouteResponseCallback& callback : request->callbacks)
     callback.Run(&route, request->presentation_id, std::string());
 
   route_requests_.Remove(jroute_request_id);
 
   active_routes_.push_back(route);
-  FOR_EACH_OBSERVER(MediaRoutesObserver, routes_observers_,
-                    OnRoutesUpdated(active_routes_));
+  for (auto it = routes_observers_.begin();
+       it != routes_observers_.end();
+       ++it) {
+    FOR_EACH_OBSERVER(MediaRoutesObserver, *it->second,
+        OnRoutesUpdated(active_routes_,
+            std::vector<MediaRoute::Id>()));
+  }
 }
 
 void MediaRouterAndroid::OnRouteRequestError(
     JNIEnv* env,
     jobject obj,
     jstring jerror_text,
     jint jroute_request_id) {
   MediaRouteRequest* request = route_requests_.Lookup(jroute_request_id);
   if (!request)
     return;
 
   std::string error_text = ConvertJavaStringToUTF8(env, jerror_text);
 
   for (const MediaRouteResponseCallback& callback : request->callbacks)
     callback.Run(nullptr, std::string(), error_text);
 
   route_requests_.Remove(jroute_request_id);
 }
 
 void MediaRouterAndroid::OnRouteClosed(JNIEnv* env,
                                        jobject obj,
                                        jstring jmedia_route_id) {
   MediaRoute::Id route_id = ConvertJavaStringToUTF8(env, jmedia_route_id);
   for (auto it = active_routes_.begin(); it != active_routes_.end(); ++it)
     if (it->media_route_id() == route_id) {
       active_routes_.erase(it);
       break;
     }
 
-  FOR_EACH_OBSERVER(MediaRoutesObserver, routes_observers_,
-                    OnRoutesUpdated(active_routes_));
+  for (auto it = routes_observers_.begin();
+       it != routes_observers_.end();
+       ++it) {
+    FOR_EACH_OBSERVER(MediaRoutesObserver, *it->second,
+        OnRoutesUpdated(active_routes_,
+            std::vector<MediaRoute::Id>()));
+  }
 }
 
 void MediaRouterAndroid::OnMessageSentResult(
     JNIEnv* env, jobject obj, jboolean jsuccess, jint jcallback_id) {
   SendRouteMessageCallback* callback = message_callbacks_.Lookup(jcallback_id);
   callback->Run(jsuccess);
   message_callbacks_.Remove(jcallback_id);
 }
 
 // Notifies the media router about a message received from the media route.
 void MediaRouterAndroid::OnMessage(
     JNIEnv* env, jobject obj, jstring jmedia_route_id, jstring jmessage) {
   MediaRoute::Id route_id = ConvertJavaStringToUTF8(env, jmedia_route_id);
   auto* observer_list = messages_observers_.get(route_id);
   if (!observer_list)
     return;
 
   ScopedVector<content::PresentationSessionMessage> session_messages;
   scoped_ptr<content::PresentationSessionMessage> message(
       new content::PresentationSessionMessage(content::TEXT));
   message->message = ConvertJavaStringToUTF8(env, jmessage);
   session_messages.push_back(message.Pass());
 
   FOR_EACH_OBSERVER(PresentationSessionMessagesObserver, *observer_list,
                     OnMessagesReceived(session_messages, true));
 }
 
 }  // namespace media_router