[Presentation API] (3rd) (1-UA) Split PresentationServiceDelegateImpl(PSDImpl)

chrome/browser/media/router/offscreen_presentation_manager.h

 // Copyright 2016 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 CHROME_BROWSER_MEDIA_ROUTER_OFFSCREEN_PRESENTATION_MANAGER_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_OFFSCREEN_PRESENTATION_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/media/router/render_frame_host_id.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/presentation_service_delegate.h"
 
 class GURL;
 
-// TODO(zhaobin): move these back to
-// content/public/browser/presentation_service_delegate.h when they are actually
-// used in content.
-namespace content {
-// TODO(zhaobin): A class stub for blink::mojom::PresentationConnectionPtr.
-// presentation.mojom is under security review. Change this to
-// blink::mojom::PresentationConnectionPtr once that is done.
-class PresentationConnectionPtr {};
-
-using ReceiverConnectionAvailableCallback =
-    base::Callback<void(const content::PresentationSessionInfo&,
-                        PresentationConnectionPtr)>;
-}  // namespace content
-
 namespace media_router {
 // Manages all offscreen presentations started in the associated Profile and
 // facilitates communication between the controllers and the receiver of an
 // offscreen presentation.
 //
 // Design doc:
 // https://docs.google.com/document/d/1XM3jhMJTQyhEC5PDAAJFNIaKh6UUEihqZDz_ztEe4Co/edit#heading=h.hadpx5oi0gml
 //
 // Example usage:
 //
@@ skipping 62 matching lines @@
 class OffscreenPresentationManager : public KeyedService {
  public:
   ~OffscreenPresentationManager() override;
 
   // Registers controller PresentationConnectionPtr to presentation
   // with |presentation_id|, |render_frame_id|.
   // Creates a new presentation if no presentation with |presentation_id|
   // exists.
   // |controller|: Not owned by this class. Ownership is transferred to the
   //               presentation receiver via |receiver_callback| passed below.
-  void RegisterOffscreenPresentationController(
+  virtual void RegisterOffscreenPresentationController(
       const std::string& presentation_id,
       const GURL& presentation_url,
       const RenderFrameHostId& render_frame_id,
       content::PresentationConnectionPtr controller);
 
   // Unregisters controller PresentationConnectionPtr to presentation with
   // |presentation_id|, |render_frame_id|. It does nothing if there is no
   // controller that matches the provided arguments. It removes presentation
   // that matches the arguments if the presentation has no receiver_callback and
   // any other pending controller.
-  void UnregisterOffscreenPresentationController(
+  virtual void UnregisterOffscreenPresentationController(
       const std::string& presentation_id,
       const RenderFrameHostId& render_frame_id);
 
   // Registers ReceiverConnectionAvailableCallback to presentation
   // with |presentation_id|.
-  void OnOffscreenPresentationReceiverCreated(
+  virtual void OnOffscreenPresentationReceiverCreated(
       const std::string& presentation_id,
       const GURL& presentation_url,
       const content::ReceiverConnectionAvailableCallback& receiver_callback);
 
   // Unregisters the ReceiverConnectionAvailableCallback associated with
   // |presentation_id|.
-  void OnOffscreenPresentationReceiverTerminated(
+  virtual void OnOffscreenPresentationReceiverTerminated(
       const std::string& presentation_id);
 
  private:
   // Represents an offscreen presentation registered with
   // OffscreenPresentationManager.
   // Contains callback to the receiver to inform it of new connections
   // established from a controller.
   // Contains set of controllers registered to OffscreenPresentationManager
   // before corresponding receiver.
   class OffscreenPresentation {
@@ skipping 39 matching lines @@
                        content::PresentationConnectionPtr,
                        RenderFrameHostIdHasher>
         pending_controllers_;
 
     DISALLOW_COPY_AND_ASSIGN(OffscreenPresentation);
   };
 
  private:
   friend class OffscreenPresentationManagerFactory;
   friend class OffscreenPresentationManagerTest;
+  friend class MockOffscreenPresentationManager;
+  FRIEND_TEST_ALL_PREFIXES(PresentationServiceDelegateImplTest,
+                           ConnectToOffscreenPresentation);
 
   // Used by OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext.
   OffscreenPresentationManager();
 
   using OffscreenPresentationMap =
       std::map<std::string, std::unique_ptr<OffscreenPresentation>>;
 
   // Creates an offscreen presentation with |presentation_id| and
   // |presentation_url|.
   OffscreenPresentation* GetOrCreateOffscreenPresentation(
       const std::string& presentation_id,
       const GURL& presentation_url);
 
   // Maps from presentation ID to OffscreenPresentation.
   OffscreenPresentationMap offscreen_presentations_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(OffscreenPresentationManager);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_OFFSCREEN_PRESENTATION_MANAGER_H_