[Media Router] Custom Controls 2 - add MediaRouter::GetRouteController()

chrome/browser/media/router/mojo/media_route_controller.cc

 // Copyright 2017 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/mojo/media_route_controller.h"
 
 #include <utility>
 
+#include "chrome/browser/media/router/media_router.h"
+
 namespace media_router {
 
 MediaRouteController::Observer::Observer(
     scoped_refptr<MediaRouteController> controller)
     : controller_(std::move(controller)) {
   controller_->AddObserver(this);
 }
 
 MediaRouteController::Observer::~Observer() {
   if (controller_)
     controller_->RemoveObserver(this);
 }
 
 void MediaRouteController::Observer::InvalidateController() {
-  controller_->RemoveObserver(this);
   controller_ = nullptr;
   OnControllerInvalidated();
 }
 
 void MediaRouteController::Observer::OnControllerInvalidated() {}
 
 MediaRouteController::MediaRouteController(
     const MediaRoute::Id& route_id,
-    mojom::MediaControllerPtr media_controller)
-    : route_id_(route_id), media_controller_(std::move(media_controller)) {
-  DCHECK(media_controller_.is_bound());
-  media_controller_.set_connection_error_handler(
-      base::Bind(&MediaRouteController::Invalidate, base::Unretained(this)));
+    mojom::MediaControllerPtr mojo_media_controller,
+    MediaRouter* media_router)
+    : route_id_(route_id),
+      mojo_media_controller_(std::move(mojo_media_controller)),
+      media_router_(media_router),
+      binding_(this) {
+  DCHECK(mojo_media_controller_.is_bound());
+  DCHECK(media_router);
+  mojo_media_controller_.set_connection_error_handler(base::Bind(
+      &MediaRouteController::OnMojoConnectionError, base::Unretained(this)));
 }
 
 void MediaRouteController::Play() {
-  media_controller_->Play();
+  DCHECK(is_valid_);
+  mojo_media_controller_->Play();
 }
 
 void MediaRouteController::Pause() {
-  media_controller_->Pause();
+  DCHECK(is_valid_);
+  mojo_media_controller_->Pause();
 }
 
 void MediaRouteController::Seek(base::TimeDelta time) {
-  media_controller_->Seek(time);
+  DCHECK(is_valid_);
+  mojo_media_controller_->Seek(time);
 }
 
 void MediaRouteController::SetMute(bool mute) {
-  media_controller_->SetMute(mute);
+  DCHECK(is_valid_);
+  mojo_media_controller_->SetMute(mute);
 }
 
 void MediaRouteController::SetVolume(float volume) {
-  media_controller_->SetVolume(volume);
+  DCHECK(is_valid_);
+  mojo_media_controller_->SetVolume(volume);
 }
 
 void MediaRouteController::OnMediaStatusUpdated(const MediaStatus& status) {
+  if (!is_valid_)

[imcheng, 2017/04/06 21:14:04]

Maybe this should be a DCHECK? This should only be called as long as binding_ is
still valid.

[takumif, 2017/04/07 21:07:55]

Okay, we'll close the mojo connection in Invalidate() so it should be safe to
DCHECK here.

+    return;
+
   for (Observer& observer : observers_)
     observer.OnMediaStatusUpdated(status);
 }
 
 void MediaRouteController::Invalidate() {
+  is_valid_ = false;
   for (Observer& observer : observers_)

[imcheng, 2017/04/06 21:14:04]

Consider cleaning up the Mojo objects here for completeness since |this| is no
longer in a usable state. IIUC, for Binding we can call Close() and for
InterfacePtr we can call reset().

[takumif, 2017/04/07 21:07:55]

Done.

     observer.InvalidateController();
   // |this| is deleted here!
 }
 
-MediaRouteController::~MediaRouteController() {}
+mojom::MediaStatusObserverPtr MediaRouteController::BindObserverPtr() {
+  DCHECK(is_valid_);
+  mojom::MediaStatusObserverPtr observer_ptr =
+      binding_.CreateInterfacePtrAndBind();
+  binding_.set_connection_error_handler(base::Bind(
+      &MediaRouteController::OnMojoConnectionError, base::Unretained(this)));
+
+  return observer_ptr;
+}
+
+MediaRouteController::~MediaRouteController() {
+  if (is_valid_)
+    media_router_->DetachRouteController(route_id_, this);
+}
 
 void MediaRouteController::AddObserver(Observer* observer) {
+  DCHECK(is_valid_);
   observers_.AddObserver(observer);
 }
 
 void MediaRouteController::RemoveObserver(Observer* observer) {
+  DCHECK(is_valid_);
   observers_.RemoveObserver(observer);
 }
 
+void MediaRouteController::OnMojoConnectionError() {
+  media_router_->DetachRouteController(route_id_, this);
+  Invalidate();
+}
+
 }  // namespace media_router