[Presentation API] Additional plumbing for PresentationServiceImpl.

content/browser/presentation/presentation_service_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_
 #define CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
 #include "content/common/presentation/presentation_service.mojom.h"
 #include "content/common/presentation/presentation_session.mojom.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/presentation_screen_availability_listener.h"
 #include "content/public/browser/presentation_service_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/frame_navigate_params.h"
 
 namespace content {
@@ skipping 25 matching lines @@
       RenderFrameHost* render_frame_host,
       mojo::InterfaceRequest<presentation::PresentationService> request);
 
  private:
   using ScreenAvailabilityMojoCallback = mojo::Callback<void(bool)>;
   using NewSessionMojoCallback =
       mojo::Callback<void(presentation::PresentationSessionInfoPtr,
           presentation::PresentationErrorPtr)>;
 
   friend class PresentationServiceImplTest;
-  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest, RemoveAllListeners);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest, Reset);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
       DidNavigateThisFrame);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
       DidNavigateNotThisFrame);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
       ThisRenderFrameDeleted);
   FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
       NotThisRenderFrameDeleted);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
+      SetDefaultPresentationUrl);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
+      SetSameDefaultPresentationUrl);
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceImplTest,
+      ClearDefaultPresentationUrl);
 
   // |render_frame_host|: The RFH this instance is associated with.
   // |web_contents|: The WebContents to observe.
   // |delegate|: Where Presentation API requests are delegated to. Not owned
   // by this class.
   PresentationServiceImpl(
       RenderFrameHost* render_frame_host,
       WebContents* web_contents,
       PresentationServiceDelegate* delegate);
 
   // PresentationService implementation.
   void GetScreenAvailability(
       const mojo::String& presentation_url,
       const ScreenAvailabilityMojoCallback& callback) override;
   void OnScreenAvailabilityListenerRemoved() override;
   void StartSession(
       const mojo::String& presentation_url,
       const mojo::String& presentation_id,
       const NewSessionMojoCallback& callback) override;
   void JoinSession(
       const mojo::String& presentation_url,
       const mojo::String& presentation_id,
       const NewSessionMojoCallback& callback) override;
+  void SetDefaultPresentationUrl(
+      const mojo::String& presentation_url) override;
 
   // mojo::InterfaceImpl override.
   // Note that this is called when the RenderFrameHost is deleted.
   void OnConnectionError() override;
 
   // WebContentsObserver override.
   void DidNavigateAnyFrame(
       content::RenderFrameHost* render_frame_host,
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override;
   void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
 
   // PresentationServiceDelegate::Observer
   void OnDelegateDestroyed() override;
 
-  // Removes all listeners on this instance and informs the
-  // PresentationServiceDelegate of such.
-  void RemoveAllListeners();
+  // Sets |default_presentation_url_| to |presentation_url| and informs the
+  // delegate of such.
+  void DoSetDefaultPresentationUrl(const std::string& presentation_url);
+
+  // Removes all listeners and resets default presentation URL on this instance
+  // and informs the PresentationServiceDelegate of such.
+  void Reset();
+
+  // Callbacks from the embedder as a result of StartSession/JoinSession.
+  void OnStartOrJoinSessionSucceeded(
+      const PresentationSessionInfo& session_info);
+  void OnStartOrJoinSessionError(const PresentationError& error);
 
   RenderFrameHost* render_frame_host_;
   PresentationServiceDelegate* delegate_;
 
   // A helper data class used by PresentationServiceImpl to do bookkeeping
   // of currently registered screen availability listeners.
   // An instance of this class is a simple state machine that waits for both
   // the available bit and the Mojo callback to become available.
   // Once this happens, the Mojo callback will be invoked with the available
   // bit, and the state machine will reset.
@@ skipping 18 matching lines @@
     void Reset();
 
     // PresentationScreenAvailabilityListener implementation.
     std::string GetPresentationUrl() const override;
     // If callback exists, it will be invoked with |available| and
     // this state machine will reset.
     // Otherwise |available| is saved for later use.
     // |available|: New screen availability for the presentation URL.
     void OnScreenAvailabilityChanged(bool available) override;
 
+    // Gets the callback as a raw pointer.
+    ScreenAvailabilityMojoCallback* callback() const {
+      return callback_ptr_.get();
+    }
+
    private:
     std::string presentation_url_;
     scoped_ptr<ScreenAvailabilityMojoCallback> callback_ptr_;
     scoped_ptr<bool> available_ptr_;
   };
 
   // Map from presentation URL to its ScreenAvailabilityContext state machine.
   base::hash_map<std::string, linked_ptr<ScreenAvailabilityContext>>
       availability_contexts_;
 
   std::string default_presentation_url_;
 
+  // This is set when there is a StartSession/JoinSession in progress.
+  // Additional StartSession/JoinSession calls are ignored while this is
+  // set.

[mark a. foltz, 2015/03/11 01:08:19]

Normally I wouldn't expect overlapping calls, but not always.  What is the
behavior the client will see in this scenario:

Promise p1 = joinSession(URL).then(...)
Promise p2 = startSession(URL)

Will p2 never resolve, or reject...?

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

For JoinSession, we should be able to let them overlap. PSImpl would just need
to know how to match up the callback with each JoinSession request. We can
choose to not allow overlapping JoinSession for the same presentation id (i.e.
if PSImpl matches callbacks by presentation ID)

For StartSession, since it brings up a dialog, it does not make sense to have
overlapping calls. We can queue up excess StartSession calls if there's one in
progress. Once the first one resolves/rejects, we can process the next request
in the queue and bring up the dialog.

I can make this change in next patch set if there are no objections.

+  // When embedder returns with a result, this callback will be invoked and then
+  // reset.
+  scoped_ptr<NewSessionMojoCallback> start_or_join_session_cb_;
+
+  // NOTE: Weak pointers must be invalidated before all other member variables.
+  base::WeakPtrFactory<PresentationServiceImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(PresentationServiceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_PRESENTATION_PRESENTATION_SERVICE_IMPL_H_