[Presentation API, Android] Implement routes observers

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_string.h"
 #include "base/guid.h"
 #include "base/logging.h"
+#include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "jni/ChromeMediaRouter_jni.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ScopedJavaLocalRef;
 using base::android::AttachCurrentThread;
 
 namespace media_router {
 
@@ skipping 139 matching lines @@
     JNIEnv* env = base::android::AttachCurrentThread();
     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) {
-  NOTIMPLEMENTED();
+  DVLOG(2) << "Added MediaRoutesObserver: " << observer;
+  routes_observers_.AddObserver(observer);
 }
 
 void MediaRouterAndroid::UnregisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
-  NOTIMPLEMENTED();
+  if (!routes_observers_.HasObserver(observer))
+    return;
+  routes_observers_.RemoveObserver(observer);
 }
 
 void MediaRouterAndroid::RegisterIssuesObserver(IssuesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void MediaRouterAndroid::UnregisterIssuesObserver(IssuesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void MediaRouterAndroid::RegisterPresentationSessionMessagesObserver(
     PresentationSessionMessagesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void MediaRouterAndroid::UnregisterPresentationSessionMessagesObserver(
     PresentationSessionMessagesObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void MediaRouterAndroid::OnSinksReceived(
     JNIEnv* env,
     jobject obj,
     jstring jsource_urn,
-    jint count) {
+    jint jcount) {
   std::vector<MediaSink> sinks_converted;
-  sinks_converted.reserve(count);
-  for (int i = 0; i < count; ++i) {
+  sinks_converted.reserve(jcount);
+  for (int i = 0; i < jcount; ++i) {
     ScopedJavaLocalRef<jstring> jsink_urn =
         Java_ChromeMediaRouter_getSinkUrn(
             env, java_media_router_.obj(), jsource_urn, i);
     ScopedJavaLocalRef<jstring> jsink_name =
         Java_ChromeMediaRouter_getSinkName(
             env, java_media_router_.obj(), jsource_urn, i);
     sinks_converted.push_back(
         MediaSink(ConvertJavaStringToUTF8(env, jsink_urn.obj()),
         ConvertJavaStringToUTF8(env, jsink_name.obj())));
   }
@@ skipping 10 matching lines @@
     JNIEnv* env,
     jobject obj,
     jstring jmedia_route_id,
     jint jcreate_route_request_id,
     jboolean jis_local) {
   CreateMediaRouteRequest* request =
       create_route_requests_.Lookup(jcreate_route_request_id);
   if (!request)
     return;
 
-  scoped_ptr<MediaRoute> route(new MediaRoute(
+  MediaRoute route(
       ConvertJavaStringToUTF8(env, jmedia_route_id),
       request->media_source,
       request->media_sink,
       std::string(),
       jis_local,
-      std::string()));
+      std::string());
 
   for (const MediaRouteResponseCallback& callback : request->callbacks)
-    callback.Run(route.get(), request->presentation_id, std::string());
+    callback.Run(&route, request->presentation_id, std::string());
 
   create_route_requests_.Remove(jcreate_route_request_id);
+
+  active_routes_.push_back(route);
+  FOR_EACH_OBSERVER(MediaRoutesObserver, routes_observers_,
+                    OnRoutesUpdated(active_routes_));
 }
 
 void MediaRouterAndroid::OnRouteCreationError(
     JNIEnv* env,
     jobject obj,
     jstring jerror_text,
     jint jcreate_route_request_id) {
   CreateMediaRouteRequest* request =
       create_route_requests_.Lookup(jcreate_route_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);
 
   create_route_requests_.Remove(jcreate_route_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_));
+}
+
 }  // namespace media_router