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/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
@@ skipping 87 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::ConnectRouteByRouteId(
+    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;
+  if (!observer->source_id().empty())
+    NOTIMPLEMENTED() << "Joinable routes query not implemented.";
+
   routes_observers_.AddObserver(observer);
 }
 
 void MediaRouterAndroid::UnregisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   if (!routes_observers_.HasObserver(observer))
     return;
   routes_observers_.RemoveObserver(observer);
 }
 
@@ skipping 85 matching lines @@
                    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_));
+      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;
@@ skipping 10 matching lines @@
                                        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_));
+      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