[MediaRouter] Renames CloseRoute() to Terminate() and creates DetachRoute()

chrome/browser/media/router/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/media_router_mojo_impl.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 296 matching lines @@
   }
 
   SetWakeReason(MediaRouteProviderWakeReason::JOIN_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoJoinRoute,
                         base::Unretained(this), source_id, presentation_id,
                         origin.is_empty() ? "" : origin.spec(), tab_id,
                         callbacks));
 }
 
-void MediaRouterMojoImpl::CloseRoute(const MediaRoute::Id& route_id) {
+void MediaRouterMojoImpl::TerminateRoute(const MediaRoute::Id& route_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  SetWakeReason(MediaRouteProviderWakeReason::CLOSE_ROUTE);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoCloseRoute,
+  SetWakeReason(MediaRouteProviderWakeReason::TERMINATE_ROUTE);
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoTerminateRoute,
                         base::Unretained(this), route_id));
 }
 
+void MediaRouterMojoImpl::DetachRoute(const MediaRoute::Id& route_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  SetWakeReason(MediaRouteProviderWakeReason::DETACH_ROUTE);
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoDetachRoute,
+                        base::Unretained(this), route_id));
+}
+
 void MediaRouterMojoImpl::SendRouteMessage(
     const MediaRoute::Id& route_id,
     const std::string& message,
     const SendRouteMessageCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_MESSAGE);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSendSessionMessage,
                         base::Unretained(this), route_id, message, callback));
 }
@@ skipping 13 matching lines @@
 void MediaRouterMojoImpl::AddIssue(const Issue& issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.AddIssue(issue);
 }
 
 void MediaRouterMojoImpl::ClearIssue(const Issue::Id& issue_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
 }
 
-void MediaRouterMojoImpl::OnPresentationSessionDetached(
-    const MediaRoute::Id& route_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  SetWakeReason(MediaRouteProviderWakeReason::PRESENTATION_SESSION_DETACHED);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoOnPresentationSessionDetached,
-                        base::Unretained(this), route_id));
-}
-
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Create an observer list for the media source and add |observer|
   // to it. Fail if |observer| is already registered.
   const std::string& source_id = observer->source().id();
   auto* sinks_query = sinks_queries_.get(source_id);
   if (!sinks_query) {
     sinks_query = new MediaSinksQuery;
@@ skipping 168 matching lines @@
     int tab_id,
     const std::vector<MediaRouteResponseCallback>& callbacks) {
   DVLOG_WITH_INSTANCE(1) << "DoJoinRoute " << source_id
                          << ", presentation ID: " << presentation_id;
   media_route_provider_->JoinRoute(
       source_id, presentation_id, origin, tab_id,
       base::Bind(&MediaRouterMojoImpl::RouteResponseReceived,
           base::Unretained(this), presentation_id, callbacks));
 }
 
-void MediaRouterMojoImpl::DoCloseRoute(const MediaRoute::Id& route_id) {
-  DVLOG_WITH_INSTANCE(1) << "DoCloseRoute " << route_id;
-  media_route_provider_->CloseRoute(route_id);
+void MediaRouterMojoImpl::DoTerminateRoute(const MediaRoute::Id& route_id) {
+  DVLOG_WITH_INSTANCE(1) << "DoTerminateRoute " << route_id;
+  media_route_provider_->TerminateRoute(route_id);
+}
+
+void MediaRouterMojoImpl::DoDetachRoute(const MediaRoute::Id& route_id) {
+  DVLOG_WITH_INSTANCE(1) << "DoDetachRoute " << route_id;
+  media_route_provider_->DetachRoute(route_id);
 }
 
 void MediaRouterMojoImpl::DoSendSessionMessage(
     const MediaRoute::Id& route_id,
     const std::string& message,
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteMessage " << route_id;
   media_route_provider_->SendRouteMessage(route_id, message, callback);
 }
 
@@ skipping 105 matching lines @@
   if (!interfaces::MediaRouter::PresentationConnectionState_IsValidValue(
           state)) {
     DLOG(WARNING) << "Unknown PresentationConnectionState value " << state;
     return;
   }
 
   NotifyPresentationConnectionStateChange(
       route_id, mojo::PresentationConnectionStateFromMojo(state));
 }
 
-void MediaRouterMojoImpl::DoOnPresentationSessionDetached(
-    const MediaRoute::Id& route_id) {
-  DVLOG_WITH_INSTANCE(1) << "DoOnPresentationSessionDetached " << route_id;
-  media_route_provider_->OnPresentationSessionDetached(route_id);
-}
-
 bool MediaRouterMojoImpl::HasLocalDisplayRoute() const {
   return has_local_display_route_;
 }
 
 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::SINK_AVAILABILITY_UNAVAILABLE)
     return;
@@ skipping 131 matching lines @@
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
 }  // namespace media_router