[Media Router] Implement JoinRoute + update CreateRoute API.

chrome/browser/media/router/presentation_service_delegate_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/presentation_service_delegate_impl.h"
 
 #include <string>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/guid.h"
@@ skipping 19 matching lines @@
 
 using content::RenderFrameHost;
 
 namespace media_router {
 
 namespace {
 
 using DelegateObserver = content::PresentationServiceDelegate::Observer;
 using RenderFrameHostId = std::pair<int, int>;
 
-// Returns the unique identifier for the supplied RenderViewHost.
-RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* render_view_host) {
-  int render_process_id = render_view_host->GetProcess()->GetID();
-  int render_frame_id = render_view_host->GetRoutingID();
+// TODO(imcheng): Presentation URL and ID should be obtained from |route|, not
+// from bound values taken from the request.
+void OnJoinRouteResponse(const std::string& presentation_url,
+                         const std::string& presentation_id,
+                         const PresentationSessionSuccessCallback& success_cb,
+                         const PresentationSessionErrorCallback& error_cb,
+                         scoped_ptr<MediaRoute> route,
+                         const std::string& error_text) {
+  if (!route.get()) {
+    error_cb.Run(content::PresentationError(
+        content::PRESENTATION_ERROR_NO_PRESENTATION_FOUND, error_text));
+  } else {
+    DVLOG(1) << "OnJoinRouteResponse: "
+             << "route_id: " << route->media_route_id()
+             << ", presentation URL: " << presentation_url
+             << ", presentation ID: " << presentation_id;
+    success_cb.Run(
+        content::PresentationSessionInfo(presentation_url, presentation_id));
+  }
+}
+
+// Returns the unique identifier for the supplied RenderFrameHost.
+RenderFrameHostId GetRenderFrameHostId(RenderFrameHost* render_frame_host) {
+  int render_process_id = render_frame_host->GetProcess()->GetID();
+  int render_frame_id = render_frame_host->GetRoutingID();
   return RenderFrameHostId(render_process_id, render_frame_id);
 }
 
 // Gets the last committed URL for the render frame specified by
 // |render_frame_host_id|.
 GURL GetLastCommittedURLForFrame(RenderFrameHostId render_frame_host_id) {
   RenderFrameHost* render_frame_host = RenderFrameHost::FromID(
       render_frame_host_id.first, render_frame_host_id.second);
+  DCHECK(render_frame_host);
   return render_frame_host->GetLastCommittedURL();
 }
 
 }  // namespace
 
 // Used by PresentationServiceDelegateImpl to manage
 // listeners and default presentation info in a render frame.
 // Its lifetime:
 //  * PresentationFrameManager AddDelegateObserver
 //  * Reset 0+ times.
@@ skipping 352 matching lines @@
 bool PresentationServiceDelegateImpl::IsMainFrame(int render_process_id,
                                                   int render_frame_id) const {
   RenderFrameHost* main_frame = web_contents_->GetMainFrame();
   return main_frame &&
          GetRenderFrameHostId(main_frame) ==
              RenderFrameHostId(render_process_id, render_frame_id);
 }
 
 void PresentationServiceDelegateImpl::
     UpdateDefaultMediaSourceAndNotifyObservers(
-        const MediaSource& default_source,
-        const GURL& default_frame_url) {
-  if (!default_source.Equals(default_source_) ||
-      default_frame_url != default_frame_url_) {
-    default_source_ = default_source;
-    default_frame_url_ = default_frame_url;
+        const MediaSource& new_default_source,
+        const GURL& new_default_frame_url) {
+  if (!new_default_source.Equals(default_source_) ||
+      new_default_frame_url != default_frame_url_) {
+    default_source_ = new_default_source;
+    default_frame_url_ = new_default_frame_url;
     FOR_EACH_OBSERVER(
         DefaultMediaSourceObserver, default_media_source_observers_,
         OnDefaultMediaSourceChanged(default_source_, default_frame_url_));
   }
 }
 
 void PresentationServiceDelegateImpl::StartSession(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_url,
@@ skipping 32 matching lines @@
   }
 }
 
 void PresentationServiceDelegateImpl::JoinSession(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_url,
     const std::string& presentation_id,
     const PresentationSessionSuccessCallback& success_cb,
     const PresentationSessionErrorCallback& error_cb) {
-  // BUG=464205
-  NOTIMPLEMENTED();
+  router_->JoinRoute(
+      MediaSourceForPresentationUrl(presentation_url).id(), presentation_id,
+      GetLastCommittedURLForFrame(
+          RenderFrameHostId(render_process_id, render_frame_id)).GetOrigin(),
+      SessionTabHelper::IdForTab(web_contents_),
+      base::Bind(&OnJoinRouteResponse, presentation_url, presentation_id,
+                 success_cb, error_cb));
 }
 
 void PresentationServiceDelegateImpl::ListenForSessionMessages(
     int render_process_id,
     int render_frame_id,
     const PresentationSessionMessageCallback& message_cb) {
   // BUG=464205
   NOTIMPLEMENTED();
 }
 
@@ skipping 47 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router