Revert of [Presentation API] Implement ondefaultsessionstart in PSImpl.

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 <algorithm>
 
 #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),
       is_start_session_pending_(false),
       next_request_session_id_(0),
       weak_factory_(this) {
-  DCHECK(render_frame_host);
+  DCHECK(render_frame_host_);
   DCHECK(web_contents);
-
-  render_process_id_ = render_frame_host->GetProcess()->GetID();
-  render_frame_id_ = render_frame_host->GetRoutingID();
   DVLOG(2) << "PresentationServiceImpl: "
-           << render_process_id_ << ", " << render_frame_id_;
+           << render_frame_host_->GetProcess()->GetID() << ", "
+           << render_frame_host_->GetRoutingID();
   if (delegate_)
-    delegate_->AddObserver(render_process_id_, render_frame_id_, this);
+    delegate_->AddObserver(this);
 }
 
 PresentationServiceImpl::~PresentationServiceImpl() {
   if (delegate_)
-    delegate_->RemoveObserver(render_process_id_, render_frame_id_);
+    delegate_->RemoveObserver(this);
   FlushNewSessionCallbacks();
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<presentation::PresentationService> request) {
   DVLOG(2) << "CreateMojoService";
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
@@ skipping 23 matching lines @@
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext*
 PresentationServiceImpl::GetOrCreateAvailabilityContext(
     const std::string& presentation_url) {
   auto it = availability_contexts_.find(presentation_url);
   if (it == availability_contexts_.end()) {
     linked_ptr<ScreenAvailabilityContext> context(
         new ScreenAvailabilityContext(presentation_url));
     if (!delegate_->AddScreenAvailabilityListener(
-        render_process_id_, render_frame_id_, context.get())) {
+        render_frame_host_->GetProcess()->GetID(),
+        render_frame_host_->GetRoutingID(),
+        context.get())) {
       DVLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
       return nullptr;
     }
     it = availability_contexts_.insert(
         std::make_pair(context->GetPresentationUrl(), context)).first;
   }
   return it->second.get();
 }
 
 void PresentationServiceImpl::ListenForScreenAvailability(
@@ skipping 19 matching lines @@
   DVLOG(2) << "RemoveScreenAvailabilityListener";
   if (!delegate_)
     return;
 
   const std::string& presentation_url_str = presentation_url.get();
   auto it = availability_contexts_.find(presentation_url_str);
   if (it == availability_contexts_.end())
     return;
 
   delegate_->RemoveScreenAvailabilityListener(
-      render_process_id_, render_frame_id_, it->second.get());
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
+      it->second.get());
   // Resolve the context's pending callbacks before removing it.
   it->second->OnScreenAvailabilityChanged(false);
   availability_contexts_.erase(it);
 }
 
 void PresentationServiceImpl::ListenForDefaultSessionStart(
     const DefaultSessionMojoCallback& callback) {
-  if (!default_session_start_context_.get())
-    default_session_start_context_.reset(new DefaultSessionStartContext);
-  default_session_start_context_->AddCallback(callback);
+  NOTIMPLEMENTED();
 }
 
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
@@ skipping 13 matching lines @@
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "JoinSession";
   if (!delegate_) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
   }
 
   int request_session_id = RegisterNewSessionCallback(callback);
   delegate_->JoinSession(
-      render_process_id_,
-      render_frame_id_,
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
       presentation_url,
       presentation_id,
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), false, request_session_id),
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
                  weak_factory_.GetWeakPtr(), false, request_session_id));
 }
 
 void PresentationServiceImpl::HandleQueuedStartSessionRequests() {
   if (queued_start_session_requests_.empty()) {
@@ skipping 23 matching lines @@
   pending_session_cbs_.clear();
 }
 
 void PresentationServiceImpl::DoStartSession(
     const std::string& presentation_url,
     const std::string& presentation_id,
     const NewSessionMojoCallback& callback) {
   int request_session_id = RegisterNewSessionCallback(callback);
   is_start_session_pending_ = true;
   delegate_->StartSession(
-      render_process_id_,
-      render_frame_id_,
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
       presentation_url,
       presentation_id,
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), true, request_session_id),
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
                  weak_factory_.GetWeakPtr(), true, request_session_id));
 }
 
 void PresentationServiceImpl::OnStartOrJoinSessionSucceeded(
     bool is_start_session,
@@ skipping 30 matching lines @@
   DCHECK(it->second.get());
   it->second->Run(session.Pass(), error.Pass());
   pending_session_cbs_.erase(it);
 }
 
 void PresentationServiceImpl::DoSetDefaultPresentationUrl(
     const std::string& default_presentation_url,
     const std::string& default_presentation_id) {
   DCHECK(delegate_);
   delegate_->SetDefaultPresentationUrl(
-      render_process_id_,
-      render_frame_id_,
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
       default_presentation_url,
       default_presentation_id);
   default_presentation_url_ = default_presentation_url;
   default_presentation_id_ = default_presentation_id;
 }
 
 void PresentationServiceImpl::SetDefaultPresentationURL(
     const mojo::String& default_presentation_url,
     const mojo::String& default_presentation_id) {
   DVLOG(2) << "SetDefaultPresentationURL";
@@ skipping 19 matching lines @@
   // Have already started listening. Create a listener for the new URL and
   // transfer the callbacks from the old listener, if any.
   // This is done so that a listener added before default URL is changed
   // will continue to work.
   ScreenAvailabilityContext* context =
       GetOrCreateAvailabilityContext(new_default_url);
   old_it->second->PassPendingCallbacks(context);
 
   // Remove listener for old default presentation URL.
   delegate_->RemoveScreenAvailabilityListener(
-      render_process_id_,
-      render_frame_id_,
+      render_frame_host_->GetProcess()->GetID(),
+      render_frame_host_->GetRoutingID(),
       old_it->second.get());
   availability_contexts_.erase(old_it);
   DoSetDefaultPresentationUrl(new_default_url, default_presentation_id);
 }
 
 void PresentationServiceImpl::CloseSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id) {
   NOTIMPLEMENTED();
 }
 
 void PresentationServiceImpl::ListenForSessionStateChange(
     const SessionStateCallback& callback) {
   NOTIMPLEMENTED();
 }
 
-bool PresentationServiceImpl::FrameMatches(
-    content::RenderFrameHost* render_frame_host) const {
-  if (!render_frame_host)
-    return false;
-
-  return render_frame_host->GetProcess()->GetID() == render_process_id_ &&
-         render_frame_host->GetRoutingID() == render_frame_id_;
-}
-
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
-  if (!FrameMatches(render_frame_host))
+  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;
 
   DVLOG(2) << "DidNavigateAnyFrame: "
           << "prev host: " << prev_url_host << ", curr host: " << curr_url_host
           << ", in_page_navigation: " << in_page_navigation;
 
   if (in_page_navigation)
     return;
 
   // Reset if the frame actually navigated.
   Reset();
 }
 
 void PresentationServiceImpl::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
   DVLOG(2) << "PresentationServiceImpl::RenderFrameDeleted";
-  if (!FrameMatches(render_frame_host))
+  if (render_frame_host_ != render_frame_host)
     return;
 
-  // RenderFrameDeleted means the associated RFH is going to be deleted soon.
+  // RenderFrameDeleted means |render_frame_host_| is going to be deleted soon.
   // This object should also be deleted.
   Reset();
+  render_frame_host_ = nullptr;
   delete this;
 }
 
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
-  if (delegate_)
-    delegate_->Reset(render_process_id_, render_frame_id_);
+  if (delegate_) {
+    delegate_->Reset(
+        render_frame_host_->GetProcess()->GetID(),
+        render_frame_host_->GetRoutingID());
+  }
 
   default_presentation_url_.clear();
   default_presentation_id_.clear();
   availability_contexts_.clear();
   queued_start_session_requests_.clear();
   FlushNewSessionCallbacks();
-  default_session_start_context_.reset();
 }
 
 // static
 void PresentationServiceImpl::InvokeNewSessionMojoCallbackWithError(
     const NewSessionMojoCallback& callback) {
   callback.Run(
         presentation::PresentationSessionInfoPtr(),
         presentation::PresentationError::From(
             PresentationError(PRESENTATION_ERROR_UNKNOWN, "Internal error")));
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
-void PresentationServiceImpl::OnDefaultPresentationStarted(
-    const PresentationSessionInfo& session) {
-  if (default_session_start_context_.get())
-    default_session_start_context_->set_session(session);
-}
-
 PresentationServiceImpl::ScreenAvailabilityContext::ScreenAvailabilityContext(
     const std::string& presentation_url)
     : presentation_url_(presentation_url) {
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext::
 ~ScreenAvailabilityContext() {
   // Ensure that pending callbacks are flushed.
   OnScreenAvailabilityChanged(false);
 }
@@ skipping 63 matching lines @@
     InvokeNewSessionMojoCallbackWithError(callback_);
 }
 
 PresentationServiceImpl::NewSessionMojoCallback
 PresentationServiceImpl::StartSessionRequest::PassCallback() {
   NewSessionMojoCallback callback = callback_;
   callback_.reset();
   return callback;
 }
 
-PresentationServiceImpl::DefaultSessionStartContext
-::DefaultSessionStartContext() {
-}
-
-PresentationServiceImpl::DefaultSessionStartContext
-::~DefaultSessionStartContext() {
-  Reset();
-}
-
-void PresentationServiceImpl::DefaultSessionStartContext::AddCallback(
-    const DefaultSessionMojoCallback& callback) {
-  if (session_.get()) {
-    DCHECK(callbacks_.empty());
-    callback.Run(presentation::PresentationSessionInfo::From(*session_));
-    session_.reset();
-  } else {
-    callbacks_.push_back(new DefaultSessionMojoCallback(callback));
-  }
-}
-
-void PresentationServiceImpl::DefaultSessionStartContext::set_session(
-    const PresentationSessionInfo& session) {
-  if (callbacks_.empty()) {
-    session_.reset(new PresentationSessionInfo(session));
-  } else {
-    DCHECK(!session_.get());
-    ScopedVector<DefaultSessionMojoCallback> callbacks;
-    callbacks.swap(callbacks_);
-    for (const auto& callback : callbacks)
-      callback->Run(presentation::PresentationSessionInfo::From(session));
-  }
-}
-
-void PresentationServiceImpl::DefaultSessionStartContext::Reset() {
-  ScopedVector<DefaultSessionMojoCallback> callbacks;
-  callbacks.swap(callbacks_);
-  for (const auto& callback : callbacks)
-    callback->Run(presentation::PresentationSessionInfoPtr());
-  session_.reset();
-}
-
 }  // namespace content