Media Remoting: Add mojo interfaces between browser and extension.

chrome/browser/media/cast_remoting_connector.cc

 // Copyright 2016 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/cast_remoting_connector.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/browser/media/cast_remoting_connector_messaging.h"

[miu, 2017/06/27 00:23:48]

You can `git rm ` this file (.h and .cc and the fuzz tests), since this isn't
being used anymore.

[xjz, 2017/06/28 02:09:38]

Done. Removed the fuzz tests.

 #include "chrome/browser/media/cast_remoting_sender.h"
 #include "chrome/browser/media/router/media_router.h"
 #include "chrome/browser/media/router/media_router_factory.h"
-#include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/common/chrome_features.h"
-#include "chrome/common/media_router/media_source_helper.h"
-#include "chrome/common/media_router/route_message.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 using content::BrowserThread;
 using media::mojom::RemotingSinkCapabilities;
 using media::mojom::RemotingStartFailReason;
 using media::mojom::RemotingStopReason;
 
-using Messaging = CastRemotingConnectorMessaging;
-
 class CastRemotingConnector::RemotingBridge : public media::mojom::Remoter {
  public:
   // Constructs a "bridge" to delegate calls between the given |source| and
   // |connector|. |connector| must be valid at the time of construction, but is
   // otherwise a weak pointer that can become invalid during the lifetime of a
   // RemotingBridge.
   RemotingBridge(media::mojom::RemotingSourcePtr source,
                  CastRemotingConnector* connector)
       : source_(std::move(source)), connector_(connector) {
     DCHECK(connector_);
@@ skipping 60 matching lines @@
  private:
   media::mojom::RemotingSourcePtr source_;
 
   // Weak pointer. Will be set to nullptr if the CastRemotingConnector is
   // destroyed before this RemotingBridge.
   CastRemotingConnector* connector_;
 
   DISALLOW_COPY_AND_ASSIGN(RemotingBridge);
 };
 
-class CastRemotingConnector::MessageObserver
-    : public media_router::RouteMessageObserver {
- public:
-  MessageObserver(media_router::MediaRouter* router,
-                  const media_router::MediaRoute::Id& route_id,
-                  CastRemotingConnector* connector)
-      : RouteMessageObserver(router, route_id), connector_(connector) {}
-  ~MessageObserver() final {}
-
- private:
-  void OnMessagesReceived(
-      const std::vector<media_router::RouteMessage>& messages) final {
-    connector_->ProcessMessagesFromRoute(messages);
-  }
-
-  CastRemotingConnector* const connector_;
-};
-
 // static
 const void* const CastRemotingConnector::kUserDataKey = &kUserDataKey;
 
 // static
 CastRemotingConnector* CastRemotingConnector::Get(
     content::WebContents* contents) {
   DCHECK(contents);
   CastRemotingConnector* connector =
       static_cast<CastRemotingConnector*>(contents->GetUserData(kUserDataKey));
   if (!connector) {
     connector = new CastRemotingConnector(
         media_router::MediaRouterFactory::GetApiForBrowserContext(
             contents->GetBrowserContext()),
-        media_router::MediaSourceForTabContentRemoting(
-            SessionTabHelper::IdForTab(contents))
-            .id());
+        SessionTabHelper::IdForTab(contents));

[miu, 2017/06/27 00:23:48]

What if IdForTab() returns -1? Should you not create a CastRemotingConnector,
and just return null?

[xjz, 2017/06/28 02:09:39]

Done.

     contents->SetUserData(kUserDataKey, base::WrapUnique(connector));
   }
   return connector;
 }
 
 // static
 void CastRemotingConnector::CreateMediaRemoter(
     content::RenderFrameHost* host,
     media::mojom::RemotingSourcePtr source,
     media::mojom::RemoterRequest request) {
   DCHECK(host);
   auto* const contents = content::WebContents::FromRenderFrameHost(host);
   if (!contents)
     return;
   CastRemotingConnector::Get(contents)->CreateBridge(std::move(source),
                                                      std::move(request));
 }
 
 namespace {
 RemotingSinkCapabilities GetFeatureEnabledCapabilities() {
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   if (base::FeatureList::IsEnabled(features::kMediaRemoting)) {
     return RemotingSinkCapabilities::RENDERING_ONLY;
   }
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
   return RemotingSinkCapabilities::NONE;
 }
 }  // namespace
 
-CastRemotingConnector::CastRemotingConnector(
-    media_router::MediaRouter* router,
-    const media_router::MediaSource::Id& media_source_id)
-    : media_router::MediaRoutesObserver(router),
-      media_source_id_(media_source_id),
+CastRemotingConnector::CastRemotingConnector(media_router::MediaRouter* router,
+                                             int32_t tab_id)
+    : media_router_(router),
+      tab_id_(tab_id),
       enabled_features_(GetFeatureEnabledCapabilities()),
-      session_counter_(0),
       active_bridge_(nullptr),
-      weak_factory_(this) {}
+      binding_(this),
+      weak_factory_(this) {
+  if (tab_id_ != -1) {

[miu, 2017/06/27 00:23:48]

Hmm...Can we prevent creating instances non-tabs? IIRC, -1 is for extension
WebContentses only. Seems like the code that calls CastRemotingConnector::Get()
should expect a null for extension WebContentses, or maybe not call Get() in the
first place?

[xjz, 2017/06/28 02:09:39]

Done.

+    VLOG(3) << "Register CastRemotingConnector for tab_id = " << tab_id_;

[miu, 2017/06/27 00:23:48]

nit: Suggest VLOG(2) for most of the VLOGs added to this file. VLOG(3) usually
means "expect a full screen or more of logging per second." VLOG(2) would be
fine for control events.

[xjz, 2017/06/28 02:09:38]

Done.

+    media_router_->RegisterRemotingSource(tab_id_, this);
+  }
+}
 
 CastRemotingConnector::~CastRemotingConnector() {
   // Assume nothing about destruction/shutdown sequence of a tab. For example,
   // it's possible the owning WebContents will be destroyed before the Mojo
   // message pipes to the RemotingBridges have been closed.
   if (active_bridge_)
     StopRemoting(active_bridge_, RemotingStopReason::ROUTE_TERMINATED);
   for (RemotingBridge* notifyee : bridges_) {
     notifyee->OnSinkGone();
     notifyee->OnCastRemotingConnectorDestroyed();
   }
+  if (tab_id_ != -1)
+    media_router_->UnregisterRemotingSource(tab_id_);
+}
+
+void CastRemotingConnector::ConnectToService(
+    media::mojom::MirrorServiceRemotingSourceRequest source_request,
+    media::mojom::MirrorServiceRemoterPtr remoter) {
+  DCHECK(!binding_.is_bound());
+  DCHECK(!remoter_);
+  DCHECK(remoter);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__;
+
+  binding_.Bind(std::move(source_request));
+  binding_.set_connection_error_handler(base::Bind(
+      &CastRemotingConnector::OnMirrorServiceStopped, base::Unretained(this)));
+  remoter_ = std::move(remoter);
+  remoter_.set_connection_error_handler(base::Bind(
+      &CastRemotingConnector::OnMirrorServiceStopped, base::Unretained(this)));
+}
+
+void CastRemotingConnector::OnMirrorServiceStopped() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__;
+
+  if (binding_.is_bound())
+    binding_.Close();
+  remoter_.reset();
+
+  for (RemotingBridge* notifyee : bridges_)

[miu, 2017/06/27 00:23:48]

Before this loop, let's call
CastRemotingConnector::StopRemoting(active_bridge_), just in case the mojo pipes
were disconnected during startup or during an active session. This will allow
for more clean-up (e.g., if there are pending audio/video data pipes that need
to be closed).

[xjz, 2017/06/28 02:09:39]

Done.

+    notifyee->OnSinkGone();
 }
 
 void CastRemotingConnector::CreateBridge(media::mojom::RemotingSourcePtr source,
                                          media::mojom::RemoterRequest request) {
   mojo::MakeStrongBinding(
       base::MakeUnique<RemotingBridge>(std::move(source), this),
       std::move(request));
 }
 
 void CastRemotingConnector::RegisterBridge(RemotingBridge* bridge) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(bridges_.find(bridge) == bridges_.end());
 
   bridges_.insert(bridge);
-  if (message_observer_ && !active_bridge_)
+  // TODO(xjz): Pass the receiver's capabilities to the source.
+  if (remoter_ && !active_bridge_)
     bridge->OnSinkAvailable(enabled_features_);
 }
 
 void CastRemotingConnector::DeregisterBridge(RemotingBridge* bridge,
                                              RemotingStopReason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(bridges_.find(bridge) != bridges_.end());
 
   if (bridge == active_bridge_)
     StopRemoting(bridge, reason);
   bridges_.erase(bridge);
 }
 
 void CastRemotingConnector::StartRemoting(RemotingBridge* bridge) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(bridges_.find(bridge) != bridges_.end());
+  VLOG(3) << __func__;
 
   // Refuse to start if there is no remoting route available, or if remoting is
   // already active.
-  if (!message_observer_) {
-    bridge->OnStartFailed(RemotingStartFailReason::ROUTE_TERMINATED);
+  if (!remoter_) {
+    VLOG(3) << "Remoting start failed: No mirror service connected.";
+    bridge->OnStartFailed(RemotingStartFailReason::SERVICE_NOT_CONNECTED);
     return;
   }
   if (active_bridge_) {
+    VLOG(3) << "Remoting start failed: Cannot start multiple.";
     bridge->OnStartFailed(RemotingStartFailReason::CANNOT_START_MULTIPLE);
     return;
   }
 
   // Notify all other sources that the sink is no longer available for remoting.
   // A race condition is possible, where one of the other sources will try to
   // start remoting before receiving this notification; but that attempt will
   // just fail later on.
   for (RemotingBridge* notifyee : bridges_) {
     if (notifyee == bridge)
       continue;
     notifyee->OnSinkGone();
   }
 
   active_bridge_ = bridge;
+  remoter_->Start();
 
-  // Send a start message to the Cast Provider.
-  ++session_counter_;  // New remoting session ID.
-  SendMessageToProvider(base::StringPrintf(
-      Messaging::kStartRemotingMessageFormat, session_counter_));
-
+  // Assumes the remoting session is always started successfully. Once any

[miu, 2017/06/27 00:23:48]

nit: s/Assumes/Assume/

[xjz, 2017/06/28 02:09:39]

Done.

+  // failure occurs, OnError() will be called.
   bridge->OnStarted();
 }
 
 void CastRemotingConnector::StartRemotingDataStreams(
     RemotingBridge* bridge,
     mojo::ScopedDataPipeConsumerHandle audio_pipe,
     mojo::ScopedDataPipeConsumerHandle video_pipe,
     media::mojom::RemotingDataStreamSenderRequest audio_sender_request,
     media::mojom::RemotingDataStreamSenderRequest video_sender_request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__;
 
   // Refuse to start if there is no remoting route available, or if remoting is
   // not active for this |bridge|.
-  if (!message_observer_ || active_bridge_ != bridge)
+  if (!remoter_ || active_bridge_ != bridge)
     return;
   // Also, if neither audio nor video pipe was provided, or if a request for a
   // RemotingDataStreamSender was not provided for a data pipe, error-out early.
   if ((!audio_pipe.is_valid() && !video_pipe.is_valid()) ||
       (audio_pipe.is_valid() && !audio_sender_request.is_pending()) ||
       (video_pipe.is_valid() && !video_sender_request.is_pending())) {
     StopRemoting(active_bridge_, RemotingStopReason::DATA_SEND_FAILED);
     return;
   }
 
   // Hold on to the data pipe handles and interface requests until one/both
   // CastRemotingSenders are created and ready for use.
   pending_audio_pipe_ = std::move(audio_pipe);
   pending_video_pipe_ = std::move(video_pipe);
   pending_audio_sender_request_ = std::move(audio_sender_request);
   pending_video_sender_request_ = std::move(video_sender_request);
 
-  // Send a "start streams" message to the Cast Provider. The provider is
-  // responsible for creating and setting up a remoting Cast Streaming session
-  // that will result in new CastRemotingSender instances being created here in
-  // the browser process.
-  SendMessageToProvider(base::StringPrintf(
-      Messaging::kStartStreamsMessageFormat, session_counter_,
-      pending_audio_sender_request_.is_pending() ? 'Y' : 'N',
-      pending_video_sender_request_.is_pending() ? 'Y' : 'N'));
+  remoter_->StartDataStreams(pending_audio_sender_request_.is_pending(),
+                             pending_video_sender_request_.is_pending());

[miu, 2017/06/27 00:23:48]

See my comments in the mojom file (for the MirrorServiceRemoter interface).
IMHO, you could make things much simpler (and fix a "wart" in my old code) if
you bind a callback here for the return values (the stream IDs). You could also
get rid of the "pending_..." member variables. Example (replacement for
L294-302):

  const bool want_audio = audio_sender_request.is_pending();
  const bool want_video = video_sender_request.is_pending();
  remoter_->StartDataStreams(want_audio, want_video,
      base::BindOnce(
          &CRC::OnDataStreamsStarted, weak_factory_.GetWeakPtr(),
          std::move(audio_pipe),
          std::move(video_pipe),
          std::move(audio_sender_request),
          std::move(video_sender_request)));

Notice that the pipe/request objects don't need to be stored as class members
anymore, since they are moved into the bound callback. That also means, if the
callback is dropped (e.g., because of a mojo error, or CRC's weak pointer is
invalidated in the meantime), the pending handles will be auto-destroyed.

[xjz, 2017/06/28 02:09:38]

Done.

+}
+
+void CastRemotingConnector::OnDataStreamsStarted(int32_t audio_stream_id,
+                                                 int32_t video_stream_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__ << ": audio_stream_id = " << audio_stream_id
+          << " video_stream_id = " << video_stream_id;
+
+  if (!active_bridge_) {

[miu, 2017/06/27 00:23:48]

Since this is asynch, just before this check, we should probably also
sanity-check that |remoter_| is valid too:

  if (!remoter_)
    return;  // Stale response to a remoter_->StartDataStreams() call.

Or, maybe this should be a DCHECK(!!remoter_), and we should always ensure that
weak_factory_.InvalidateWeakPtrs() is called whenever remoter_ is set to null?

[xjz, 2017/06/28 02:09:39]

Done with DCHECK. Whenever remoter_ is set to null, StopRemoting() is called,
which will invalidate the weak ptr.

+    remoter_->Stop(media::mojom::RemotingStopReason::SOURCE_GONE);
+    return;
+  }
+
+  if (pending_audio_sender_request_.is_pending()) {

[miu, 2017/06/27 00:23:48]

nit: "&& audio_stream_id > 0"

... and for video too.

[xjz, 2017/06/28 02:09:39]

Done.

+    cast::CastRemotingSender::FindAndBind(
+        audio_stream_id, std::move(pending_audio_pipe_),
+        std::move(pending_audio_sender_request_),
+        base::Bind(&CastRemotingConnector::OnDataSendFailed,
+                   weak_factory_.GetWeakPtr()));
+  }
+  if (pending_video_sender_request_.is_pending()) {
+    cast::CastRemotingSender::FindAndBind(
+        video_stream_id, std::move(pending_video_pipe_),
+        std::move(pending_video_sender_request_),
+        base::Bind(&CastRemotingConnector::OnDataSendFailed,
+                   weak_factory_.GetWeakPtr()));
+  }
 }
 
 void CastRemotingConnector::StopRemoting(RemotingBridge* bridge,
                                          RemotingStopReason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__ << ": reason = " << reason;
 
   if (active_bridge_ != bridge)
     return;
 
   active_bridge_ = nullptr;
 
   // Explicitly close the data pipes (and related requests) just in case the
   // "start streams" operation was interrupted.
   pending_audio_pipe_.reset();
   pending_video_pipe_.reset();
   pending_audio_sender_request_ = nullptr;
   pending_video_sender_request_ = nullptr;
 
   // Cancel all outstanding callbacks related to the remoting session.
   weak_factory_.InvalidateWeakPtrs();
 
   // Prevent the source from trying to start again until the Cast Provider has
   // indicated the stop operation has completed.
   bridge->OnSinkGone();
   // Note: At this point, all sources should think the sink is gone.
 
-  SendMessageToProvider(base::StringPrintf(
-      Messaging::kStopRemotingMessageFormat, session_counter_));
-  // Note: Once the Cast Provider sends back an acknowledgement message, all
-  // sources will be notified that the remoting sink is available again.
+  if (remoter_)
+    remoter_->Stop(reason);
 
   bridge->OnStopped(reason);
 }
 
+void CastRemotingConnector::OnStopped(RemotingStopReason reason) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__ << ": reason = " << reason;
+
+  if (!active_bridge_) {
+    // Notify all the sources that the sink is available again.
+    if (remoter_) {
+      // TODO(xjz): Pass the receiver's capabilities to sources.
+      for (RemotingBridge* notifyee : bridges_) {
+        notifyee->OnSinkAvailable(enabled_features_);

[miu, 2017/06/27 00:23:48]

Instead of this, it seems we should require that MirrorServiceRemoter call
OnSinkAvailable() when it's ready again?

[xjz, 2017/06/28 02:09:39]

I think OnStopped() call already indicates that MirrorServiceRemoter is ready
for next remoting session. Also, the receiver's capabilities are supposed
unchanged during a cast session. So OnSinkAvailable() is only called once from
the MirrorServiceRemoter when it is started. CastRemotingConnector controls
telling availability/capabilities to all RemotingSources as it currently does.
WDYT?

[miu, 2017/06/29 20:46:50]

There is a significant period of time (1-3 seconds) between "stopped this
session" and "ready to start the next session." For example, it takes time to
switch the Chromecast back into mirroring mode; and we don't want to say
remoting is ready until that has completed. That is why the separate
OnSinkAvailable() is necessary.

Also, why must Capabilities be constant? There are reasons it could be
different, after learning something from executing the last remoting session.
For example, network bandwidth capacity/latency may have been worse than
originally anticipated; or maybe the device reports support for some codec or
feature that it actually does not support (not that this would ever happen).

[xjz, 2017/06/30 02:12:09]

Done as discussed offline.

+      }
+    }
+    return;
+  }
+  StopRemoting(active_bridge_, reason);
+}
+
 void CastRemotingConnector::SendMessageToSink(
     RemotingBridge* bridge, const std::vector<uint8_t>& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // During an active remoting session, simply pass all binary messages through
   // to the sink.
-  if (!message_observer_ || active_bridge_ != bridge)
+  if (!remoter_ || active_bridge_ != bridge)
     return;
-  media_router::MediaRoutesObserver::router()->SendRouteBinaryMessage(
-      message_observer_->route_id(),
-      base::MakeUnique<std::vector<uint8_t>>(message),
-      base::Bind(&CastRemotingConnector::HandleSendMessageResult,
-                 weak_factory_.GetWeakPtr()));
+  remoter_->SendMessageToSink(message);
 }
 
-void CastRemotingConnector::SendMessageToProvider(const std::string& message) {
+void CastRemotingConnector::OnMessageFromSink(
+    const std::vector<uint8_t>& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  if (!message_observer_)
+  // During an active remoting session, simply pass all binary messages through
+  // to the source.
+  if (!active_bridge_)
+    return;
+  active_bridge_->OnMessageFromSink(message);
+}
+
+void CastRemotingConnector::OnSinkAvailable(
+    media::mojom::RemotingSinkCapabilities capabilities) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__ << ": capabilities = " << capabilities;
+
+  // The receiver's capabilities are supposed unchanged during an active
+  // remoting session.
+  if (active_bridge_)

[miu, 2017/06/27 00:23:48]

I'm trying to think why OnSinkAvailable() would be called during an active
session. It doesn't seem like it should. Perhaps this code should shut down what
was running before? In other words, OnSinkAvailable() seems like a "ready to
start next session" control signal.

  if (active_bridge) {
    LOG(WARNING) << "Unexpected OnSinkAvailable() signal: Shutting-down active
bridge.";
    StopRemoting(active_bridge, ...something appropriate here...);
  }

[xjz, 2017/06/28 02:09:39]

Yes, I agree. As replied to the comment above, OnSinkAvailable() is actually
only called once by MirrorServiceRemoter. How about just ignore the call during
an active remoting session?

     return;
 
-  if (active_bridge_) {
-    media_router::MediaRoutesObserver::router()->SendRouteMessage(
-        message_observer_->route_id(), message,
-        base::Bind(&CastRemotingConnector::HandleSendMessageResult,
-                   weak_factory_.GetWeakPtr()));
-  } else {
-    struct Helper {
-      static void IgnoreSendMessageResult(bool ignored) {}
-    };
-    media_router::MediaRoutesObserver::router()->SendRouteMessage(
-        message_observer_->route_id(), message,
-        base::Bind(&Helper::IgnoreSendMessageResult));
-  }
+  // TODO(xjz): Pass the receiver's capabilities to the sources.
+  for (RemotingBridge* notifyee : bridges_)
+    notifyee->OnSinkAvailable(enabled_features_);
 }
 
-void CastRemotingConnector::ProcessMessagesFromRoute(
-    const std::vector<media_router::RouteMessage>& messages) {
+void CastRemotingConnector::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__;
 
-  // Note: If any calls to message parsing functions are added/changed here,
-  // please update cast_remoting_connector_fuzzertest.cc as well!
-
-  for (const media_router::RouteMessage& message : messages) {
-    switch (message.type) {
-      case media_router::RouteMessage::TEXT:
-        // This is a notification message from the Cast Provider, about the
-        // execution state of the media remoting session between Chrome and the
-        // remote device.
-        DCHECK(message.text);
-
-        // If this is a "start streams" acknowledgement message, the
-        // CastRemotingSenders should now be available to begin consuming from
-        // the data pipes.
-        if (active_bridge_ &&
-            Messaging::IsMessageForSession(
-                *message.text,
-                Messaging::kStartedStreamsMessageFormatPartial,
-                session_counter_)) {
-          if (pending_audio_sender_request_.is_pending()) {
-            cast::CastRemotingSender::FindAndBind(
-                Messaging::GetStreamIdFromStartedMessage(
-                    *message.text,
-                    Messaging::kStartedStreamsMessageAudioIdSpecifier),
-                std::move(pending_audio_pipe_),
-                std::move(pending_audio_sender_request_),
-                base::Bind(&CastRemotingConnector::OnDataSendFailed,
-                           weak_factory_.GetWeakPtr()));
-          }
-          if (pending_video_sender_request_.is_pending()) {
-            cast::CastRemotingSender::FindAndBind(
-                Messaging::GetStreamIdFromStartedMessage(
-                    *message.text,
-                    Messaging::kStartedStreamsMessageVideoIdSpecifier),
-                std::move(pending_video_pipe_),
-                std::move(pending_video_sender_request_),
-                base::Bind(&CastRemotingConnector::OnDataSendFailed,
-                           weak_factory_.GetWeakPtr()));
-          }
-          break;
-        }
-
-        // If this is a failure message, call StopRemoting().
-        if (active_bridge_ &&
-            Messaging::IsMessageForSession(*message.text,
-                                           Messaging::kFailedMessageFormat,
-                                           session_counter_)) {
-          StopRemoting(active_bridge_, RemotingStopReason::UNEXPECTED_FAILURE);
-          break;
-        }
-
-        // If this is a stop acknowledgement message, indicating that the last
-        // session was stopped, notify all sources that the sink is once again
-        // available.
-        if (Messaging::IsMessageForSession(*message.text,
-                                           Messaging::kStoppedMessageFormat,
-                                           session_counter_)) {
-          if (active_bridge_) {
-            // Hmm...The Cast Provider was in a state that disagrees with this
-            // connector. Attempt to resolve this by shutting everything down to
-            // effectively reset to a known state.
-            LOG(WARNING) << "BUG: Cast Provider sent 'stopped' message during "
-                            "an active remoting session.";
-            StopRemoting(active_bridge_,
-                         RemotingStopReason::UNEXPECTED_FAILURE);
-          }
-          for (RemotingBridge* notifyee : bridges_)
-            notifyee->OnSinkAvailable(enabled_features_);
-          break;
-        }
-
-        LOG(WARNING) << "BUG: Unexpected message from Cast Provider: "
-                     << *message.text;
-        break;
-
-      case media_router::RouteMessage::BINARY:  // This is for the source.
-        DCHECK(message.binary);
-
-        // All binary messages are passed through to the source during an active
-        // remoting session.
-        if (active_bridge_)
-          active_bridge_->OnMessageFromSink(*message.binary);
-        break;
-    }
-  }
-}
-
-void CastRemotingConnector::HandleSendMessageResult(bool success) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  // A single message send failure is treated as fatal to an active remoting
-  // session.
-  if (!success && active_bridge_)
-    StopRemoting(active_bridge_, RemotingStopReason::MESSAGE_SEND_FAILED);
+  if (active_bridge_)
+    StopRemoting(active_bridge_, RemotingStopReason::UNEXPECTED_FAILURE);
 }
 
 void CastRemotingConnector::OnDataSendFailed() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  VLOG(3) << __func__;
+
   // A single data send failure is treated as fatal to an active remoting
   // session.
   if (active_bridge_)
     StopRemoting(active_bridge_, RemotingStopReason::DATA_SEND_FAILED);
 }
-
-void CastRemotingConnector::OnRoutesUpdated(
-    const std::vector<media_router::MediaRoute>& routes,
-    const std::vector<media_router::MediaRoute::Id>& joinable_route_ids) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  // If a remoting route has already been identified, check that it still
-  // exists. Otherwise, shut down messaging and any active remoting, and notify
-  // the sources that remoting is no longer available.
-  if (message_observer_) {
-    for (const media_router::MediaRoute& route : routes) {
-      if (message_observer_->route_id() == route.media_route_id())
-        return;  // Remoting route still exists. Take no further action.
-    }
-    message_observer_.reset();
-    if (active_bridge_)
-      StopRemoting(active_bridge_, RemotingStopReason::ROUTE_TERMINATED);
-    for (RemotingBridge* notifyee : bridges_)
-      notifyee->OnSinkGone();
-  }
-
-  // There shouldn't be an active RemotingBridge at this point, since there is
-  // currently no known remoting route.
-  DCHECK(!active_bridge_);
-
-  // Scan |routes| for a new remoting route. If one is found, begin processing
-  // messages on the route, and notify the sources that remoting is now
-  // available.
-  for (const media_router::MediaRoute& route : routes) {
-    if (route.media_source().id() != media_source_id_)
-      continue;
-    message_observer_.reset(new MessageObserver(
-        media_router::MediaRoutesObserver::router(), route.media_route_id(),
-        this));
-    // TODO(miu): In the future, scan the route ID for sink capabilities
-    // properties and pass these to the source in the OnSinkAvailable()
-    // notification.
-    for (RemotingBridge* notifyee : bridges_)
-      notifyee->OnSinkAvailable(enabled_features_);
-    break;
-  }
-}