[Presentation API] Additional plumbing for PresentationServiceImpl.

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include "base/logging.h"
+#include "content/browser/presentation/presentation_type_converters.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_details.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 "content/public/common/content_client.h"
 #include "content/public/common/frame_navigate_params.h"
 
 namespace content {
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     PresentationServiceDelegate* delegate)
     : WebContentsObserver(web_contents),
       render_frame_host_(render_frame_host),
-      delegate_(delegate) {
+      delegate_(delegate),
+      weak_factory_(this) {
   DCHECK(render_frame_host_);
   DCHECK(web_contents);
   VLOG(2) << "PresentationServiceImpl: "
           << render_frame_host_->GetProcess()->GetID() << ", "
           << render_frame_host_->GetRoutingID();
   if (delegate_)
     delegate_->AddObserver(this);
 }
 
 PresentationServiceImpl::~PresentationServiceImpl() {
   if (delegate_)
     delegate_->RemoveObserver(this);
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<presentation::PresentationService> request) {
-  VLOG(2) << "PresentationServiceImpl::CreateService";
+  VLOG(2) << "CreateMojoService";
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(web_contents);
 
   mojo::BindToRequest(
       new PresentationServiceImpl(
           render_frame_host,
           web_contents,
           GetContentClient()->browser()->GetPresentationServiceDelegate(
               web_contents)),
           &request);
 }
 
 void PresentationServiceImpl::OnConnectionError() {
-  VLOG(1) << "PresentationServiceImpl::OnConnectionError: "
+  VLOG(1) << "OnConnectionError: "
           << render_frame_host_->GetProcess()->GetID() << ", "
           << render_frame_host_->GetRoutingID();
 }
 
 void PresentationServiceImpl::GetScreenAvailability(
     const mojo::String& presentation_url,
     const ScreenAvailabilityMojoCallback& callback) {
-  VLOG(2) << "PresentationServiceImpl::GetScreenAvailability";
+  VLOG(2) << "GetScreenAvailability";
   if (!delegate_)
     return;
 
   const std::string& presentation_url_str = !presentation_url.is_null() ?
       presentation_url.get() : default_presentation_url_;
 
   // GetScreenAvailability() is called with no URL and there is no default
   // Presentation URL.

[whywhat, 2015/03/10 17:05:04]

BTW, are we going to support this situation for the 1UA case?
We don't have the DPU in the spec (yet) and certainly don't want to require it
from the websites for the availability to work.

[imcheng, 2015/03/10 18:31:15]

Maybe there's something I don't understand here.

When obtaining screen availability, we will need a presentation URL to work
with. It either comes from the DPU (if set) or provided as |presentation_url|
parameter in this function. If neither one exists, how would the media router
know how to filter out inapplicable devices? Also, PSDispatcher is currently
always passing in an empty string here. Does that need to be fixed?

[whywhat, 2015/03/10 23:20:22]

I believe that the absence of DPU from the spec means: search for universal
screens (e.g. wired/wireless monitors we could mirror the presentation to;
Presentation API remote screens that can render any URL without limitations). In
the code absence of DPU currently means - no screens available.

I'm working on a CL that would parse the <link> tags to determine DPU. We would
pass the same DPU to GetScreenAvailability() for now since the API doesn't have
a way to specify a URL for filtering when requesting screen availability.

[imcheng, 2015/03/12 20:03:40]

Ok, gotcha. We also talked about this briefly in the meeting today, to pass a
generic source to media router in the case of no DPU. I will think about how to
modify this code to make it work for that case.

-  if (presentation_url_str.empty())
+  if (presentation_url_str.empty()) {
+    VLOG(1) << "No valid presentation URL.";
     return;
+  }
 
   auto it = availability_contexts_.find(presentation_url_str);
   if (it == availability_contexts_.end()) {
     linked_ptr<ScreenAvailabilityContext> context(
         new ScreenAvailabilityContext(presentation_url_str));
 
     if (!delegate_->AddScreenAvailabilityListener(
         render_frame_host_->GetProcess()->GetID(),
         render_frame_host_->GetRoutingID(),
         context.get())) {
       VLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
       return;
     }
 
     it = availability_contexts_.insert(
-        std::make_pair(presentation_url_str, context)).first;
+        std::make_pair(context->GetPresentationUrl(), context)).first;
   }
 
   it->second->CallbackReceived(callback);
 }
 
 void PresentationServiceImpl::OnScreenAvailabilityListenerRemoved() {
-  NOTIMPLEMENTED();
+  VLOG(2) << "OnScreenAvailabilityListenerRemoved";
+  if (!delegate_)
+    return;
+
+  const std::string presentation_url_str = default_presentation_url_;

[whywhat, 2015/03/10 17:05:04]

It seems like you could eliminate this whole paragraph and just pass
default_presentation_url_ to the find() method (the empty string won't be found
anyway). You don't use presentation_url_str anywhere afterwards as far as I can
see.

[imcheng, 2015/03/10 18:31:15]

Done. But shouldn't we support removing listener by presentation URL?

[whywhat, 2015/03/10 23:20:22]

Yes, but we don't pass a URL there yet. Let's fix it when we do pass it.
I assume your intention was something like:

void PresentationServiceImpl::OnScreenAvailabilityListenerRemoved(const
std::string& presentation_url) {
  if (presentation_url.empty())
    presentation_url = default_presentation_url_;

?
}

[imcheng, 2015/03/12 20:03:40]

I see you have added the param to the .mojom in your other patch. I will add the
change here as well and implement similar logic as GetScreenAvailability() here.

+  if (presentation_url_str.empty())
+    return;
+
+  auto it = availability_contexts_.find(presentation_url_str);
+  if (it == availability_contexts_.end())
+    return;
+
+  delegate_->RemoveScreenAvailabilityListener(
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      it->second.get());
+  availability_contexts_.erase(it);
 }
 
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
-  NOTIMPLEMENTED();
+  if (start_or_join_session_cb_.get())
+    return;

[whywhat, 2015/03/10 17:05:04]

VLOG?

[imcheng, 2015/03/10 18:31:15]

Done.

+
+  delegate_->StartSession(
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      presentation_url,
+      presentation_id,
+      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
+                 weak_factory_.GetWeakPtr()));
+  start_or_join_session_cb_.reset(new NewSessionMojoCallback(callback));
 }
 
 void PresentationServiceImpl::JoinSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
-  NOTIMPLEMENTED();
+  if (start_or_join_session_cb_.get())
+    return;
+
+  delegate_->JoinSession(
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      presentation_url,
+      presentation_id,
+      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
+                 weak_factory_.GetWeakPtr()));
+  start_or_join_session_cb_.reset(new NewSessionMojoCallback(callback));
+}
+
+void PresentationServiceImpl::OnStartOrJoinSessionSucceeded(
+    const PresentationSessionInfo& session_info) {
+  CHECK(start_or_join_session_cb_.get());
+  start_or_join_session_cb_->Run(
+      presentation::PresentationSessionInfo::From(session_info),
+      presentation::PresentationErrorPtr());
+  start_or_join_session_cb_.reset();
+}
+
+void PresentationServiceImpl::OnStartOrJoinSessionError(
+    const PresentationError& error) {
+  CHECK(start_or_join_session_cb_.get());
+  start_or_join_session_cb_->Run(
+      presentation::PresentationSessionInfoPtr(),
+      presentation::PresentationError::From(error));
+  start_or_join_session_cb_.reset();
+}
+
+
+void PresentationServiceImpl::DoSetDefaultPresentationUrl(
+    const std::string& presentation_url) {
+  delegate_->SetDefaultPresentationUrl(
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      presentation_url);
+  default_presentation_url_ = presentation_url;
+}
+
+void PresentationServiceImpl::SetDefaultPresentationUrl(
+    const mojo::String& presentation_url) {
+  VLOG(2) << "SetDefaultPresentationUrl";
+  if (!delegate_)
+    return;
+
+  std::string old_default_url = default_presentation_url_;
+  std::string new_default_url = presentation_url;
+
+  if (old_default_url == new_default_url)
+    return;
+
+  if (old_default_url.empty()) {
+    DoSetDefaultPresentationUrl(new_default_url);
+    return;
+  }
+
+  auto old_it = availability_contexts_.find(old_default_url);
+  // Haven't started listening yet.
+  if (old_it == availability_contexts_.end()) {
+    DoSetDefaultPresentationUrl(new_default_url);
+    return;
+  }
+
+  // Have already started listening. Create a listener for the new URL and
+  // transfer the callback from the old listener, if any.
+  // This is done so that a listener added before default URL is changed
+  // will continue to work.
+  ScreenAvailabilityMojoCallback* old_callback = old_it->second->callback();
+  if (!new_default_url.empty()) {
+    auto new_it = availability_contexts_.find(new_default_url);
+    if (new_it == availability_contexts_.end()) {
+      linked_ptr<ScreenAvailabilityContext> context(
+          new ScreenAvailabilityContext(new_default_url));
+      if (!delegate_->AddScreenAvailabilityListener(
+          render_frame_host_->GetProcess()->GetID(),
+          render_frame_host_->GetRoutingID(),
+          context.get())) {
+        VLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
+        return;
+      }
+      new_it = availability_contexts_.insert(
+          std::make_pair(context->GetPresentationUrl(), context)).first;
+    }
+    if (old_callback)
+      new_it->second->CallbackReceived(*old_callback);
+  }
+
+  // Remove listener for old default presentation URL.
+  delegate_->RemoveScreenAvailabilityListener(
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      old_it->second.get());
+  availability_contexts_.erase(old_it);
+  DoSetDefaultPresentationUrl(new_default_url);
 }
 
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   VLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (render_frame_host_ != render_frame_host)
     return;
 
   std::string prev_url_host = details.previous_url.host();
   std::string curr_url_host = params.url.host();
 
   // If a frame navigation is in-page (e.g. navigating to a fragment in
   // same page) then we do not unregister listeners.
   bool in_page_navigation = details.is_in_page ||
       details.type == content::NAVIGATION_TYPE_IN_PAGE;
 
   VLOG(2) << "DidNavigateAnyFrame: "
           << "prev host: " << prev_url_host << ", curr host: " << curr_url_host
           << ", in_page_navigation: " << in_page_navigation;
 
   if (in_page_navigation)
     return;
 
-  // Unregister all sources if the frame actually navigated.
-  RemoveAllListeners();
+  // Reset if the frame actually navigated.
+  Reset();
 }
 
 void PresentationServiceImpl::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
   VLOG(2) << "PresentationServiceImpl::RenderFrameDeleted";
   if (render_frame_host_ != render_frame_host)
     return;
 
   // RenderFrameDeleted means this object is getting deleted soon.
-  RemoveAllListeners();
+  Reset();
 }
 
-void PresentationServiceImpl::RemoveAllListeners() {
-  VLOG(2) << "PresentationServiceImpl::RemoveAllListeners";
+void PresentationServiceImpl::Reset() {
+  VLOG(2) << "PresentationServiceImpl::Reset";
   if (!delegate_)
     return;
 
+  // Unregister all sources.
   delegate_->RemoveAllScreenAvailabilityListeners(
         render_frame_host_->GetProcess()->GetID(),
         render_frame_host_->GetRoutingID());
+  availability_contexts_.clear();
 
-  availability_contexts_.clear();
+  // Clear default presentation URL.
+  DoSetDefaultPresentationUrl(std::string());
+
+  start_or_join_session_cb_.reset();
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   VLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
+  start_or_join_session_cb_.reset();
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext::ScreenAvailabilityContext(
     const std::string& presentation_url)
     : presentation_url_(presentation_url) {
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext::
 ~ScreenAvailabilityContext() {
 }
@@ skipping 31 matching lines @@
   } else {
     // Invoke callback and erase it.
     // There shouldn't be any result stored in this scenario.
     DCHECK(!available_ptr_);
     callback_ptr_->Run(available);
     Reset();
   }
 }
 
 }  // namespace content