media::mojom::Remoter and CastRemotingConnector/Sender

chrome/browser/media/router/mojo/media_router_mojo_impl.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/router/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/media_source_helper.h"
+#include "chrome/browser/media/router/mojo/media_remoting_session_impl.h"
 #include "chrome/browser/media/router/mojo/media_route_provider_util_win.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/mojo/media_router_type_converters.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
@@ skipping 60 matching lines @@
   DCHECK(event_page_tracker_);
 #if defined(OS_WIN)
   CanFirewallUseLocalPorts(
       base::Bind(&MediaRouterMojoImpl::OnFirewallCheckComplete,
                  weak_factory_.GetWeakPtr()));
 #endif
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  TerminateAllRemotingSessions("media router shutdown");
 }
 
 // static
 void MediaRouterMojoImpl::BindToRequest(
     const extensions::Extension* extension,
     content::BrowserContext* context,
     mojo::InterfaceRequest<interfaces::MediaRouter> request) {
   MediaRouterMojoImpl* impl = static_cast<MediaRouterMojoImpl*>(
       MediaRouterFactory::GetApiForBrowserContext(context));
   DCHECK(impl);
@@ skipping 14 matching lines @@
   media_route_provider_extension_id_ = extension.id();
   if (!provider_version_was_recorded_) {
     MediaRouterMojoMetrics::RecordMediaRouteProviderVersion(extension);
     provider_version_was_recorded_ = true;
   }
 }
 
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  TerminateAllRemotingSessions("internal connection error");
   media_route_provider_.reset();
   binding_.reset();
 
   // If |OnConnectionError| is invoked while there are pending requests, then
   // it means we tried to wake the extension, but weren't able to complete the
   // connection to media route provider. Since we do not know whether the error
   // is transient, reattempt the wakeup.
   if (!pending_requests_.empty()) {
     DLOG_WITH_INSTANCE(ERROR) << "A connection error while there are pending "
                                  "requests.";
@@ skipping 653 matching lines @@
 
 void MediaRouterMojoImpl::OnPresentationConnectionClosed(
     const mojo::String& route_id,
     interfaces::MediaRouter::PresentationConnectionCloseReason reason,
     const mojo::String& message) {
   NotifyPresentationConnectionClose(
       route_id, mojo::PresentationConnectionCloseReasonFromMojo(reason),
       message);
 }
 
+void MediaRouterMojoImpl::CreateRemotingSession(
+    const mojo::String& media_source,
+    interfaces::MediaRemotingProviderPtr provider,
+    const CreateRemotingSessionCallback& callback) {
+  DVLOG_WITH_INSTANCE(1)
+      << "CreateRemotingSession(media_source=" << media_source << ")";
+
+  interfaces::MediaRemotingSessionPtr session_ptr;
+  do {
+    content::WebContents* const source_contents =
+        WebContentsFromMediaSource(MediaSource(media_source));
+    if (!source_contents) {
+      // Note: This can happen if the tab existed at the time the client called
+      // CreateRemotingSession(), but was closed before this service method was
+      // invoked.
+      DLOG_WITH_INSTANCE(WARNING)
+          << "Cannot find WebContents instance specified by the media source.";
+      break;
+    }
+
+    if (!provider.is_bound()) {
+      DLOG_WITH_INSTANCE(ERROR)
+          << "Client did not pass a bound MediaRemotingProvider interface.";
+      break;
+    }
+
+    std::unique_ptr<MediaRemotingSessionImpl>& session =
+        remoting_sessions_[media_source];
+    if (session) {
+      DLOG_WITH_INSTANCE(ERROR)
+          << "Cannot create multiple MediaRemotingSessions per media source.";
+      break;
+    }
+    session.reset(
+        new AutoTerminatingRemotingSession(
+            source_contents, std::move(provider), GetProxy(&session_ptr),
+            base::Bind(&MediaRouterMojoImpl::OnRemotingSessionTerminated,
+                       base::Unretained(this), media_source)));
+  } while (false);
+
+  callback.Run(std::move(session_ptr));
+}
+
+void MediaRouterMojoImpl::OnRemotingSessionTerminated(
+    const MediaSource::Id& media_source) {
+  remoting_sessions_.erase(media_source);
+}
+
+void MediaRouterMojoImpl::TerminateAllRemotingSessions(
+    const std::string& error_reason) {
+  // Copy pointers to a separate vector for iteration, since terminating each
+  // session will cause the |remoting_sessions_| map to mutate.
+  std::vector<MediaRemotingSessionImpl*> sessions;
+  for (const auto& entry : remoting_sessions_)
+    sessions.push_back(entry.second.get());
+
+  for (MediaRemotingSessionImpl* session : sessions)
+    session->Terminate(error_reason);
+  DCHECK(remoting_sessions_.empty());
+}
+
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
   // No need to call MRPM if there are no sinks available.
   if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE)
     return;
 
   // No need to call MRPM if all observers have been removed in the meantime.
   auto* sinks_query = sinks_queries_.get(source_id);
   if (!sinks_query || !sinks_query->observers.might_have_observers())
@@ skipping 192 matching lines @@
                         base::Unretained(this), source_id));
 }
 
 void MediaRouterMojoImpl::DoUpdateMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoUpdateMediaSinks" << source_id;
   media_route_provider_->UpdateMediaSinks(source_id);
 }
 
 }  // namespace media_router