Move media::mojom::RemoterFactory to content, add ContentBrowserClient API.

chrome/browser/media/cast_remoting_connector.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_CAST_REMOTING_CONNECTOR_H_
 #define CHROME_BROWSER_MEDIA_CAST_REMOTING_CONNECTOR_H_
 
 #include <set>
 
 #include "base/memory/weak_ptr.h"
 #include "base/supports_user_data.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/route_message.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
 
 namespace content {
 class RenderFrameHost;
 class WebContents;
 }
 
 // CastRemotingConnector connects a single source (a media element in a render
 // frame) with a single sink (a media player in a remote device). There is one
 // instance of a CastRemotingConnector per source WebContents (representing a
 // collection of render frames), and it is created on-demand. The source in the
 // render process represents itself by providing a media::mojom::RemotingSource
 // service instance. The sink is represented by the Media Router Cast Provider.
 //
-// Whenever a RenderFrameHost is created, ChromeContentBrowserClient will call
-// CreateRemoterFactory() to instantiate an implementation of
-// media::mojom::RemoterFactory associated with the connector. This allows one
-// or more media sources in a render frame to create a media::mojom::Remoter to
-// start/stop and execute media remoting. Media sources also provide a
-// media::mojom::RemotingSource so that the connector may notify them when a
-// sink becomes available for remoting and pass binary messages from the sink
-// back to the source.
+// Whenever a candidate media source is created in a render frame,
+// ChromeContentBrowserClient will call CreateMediaRemoter() to instantiate a
+// media::mojom::Remoter associated with the connector. A corresponding
+// media::mojom::RemotingSource is provided by the caller for communications
+// back to the media source in the render frame: The connector uses this to
+// notify when a sink becomes available for remoting, and to pass binary
+// messages from the sink back to the source.
 //
 // At any time before or after the CastRemotingConnector is created, the
 // Media Router Cast Provider may create a tab remoting media route. This
 // indicates that the provider has found a sink that is capable of remoting and
 // is available for use. At this point, CastRemotingConnector notifies all
 // RemotingSources that a sink is available, and some time later a
 // RemotingSource can request the start of a remoting session. Once the sink is
 // no longer available, the provider terminates the route and
 // CastRemotingConnector notifies all RemotingSources that the sink is gone.
 //
@@ skipping 19 matching lines @@
 // start/execute/stop remoting sessions.
 class CastRemotingConnector
     : public base::SupportsUserData::Data,
       public media_router::MediaRoutesObserver {
  public:
   // Returns the instance of the CastRemotingConnector associated with
   // |source_contents|, creating a new instance if needed.
   static CastRemotingConnector* Get(content::WebContents* source_contents);
 
   // Used by ChromeContentBrowserClient to request a binding to a new
-  // RemoterFactory for each new render frame.
-  static void CreateRemoterFactory(content::RenderFrameHost* render_frame_host,
-                                   media::mojom::RemoterFactoryRequest request);
+  // Remoter for each new source in a render frame.
+  static void CreateMediaRemoter(content::RenderFrameHost* render_frame_host,
+                                 media::mojom::RemotingSourcePtr source,
+                                 media::mojom::RemoterRequest request);
 
  private:
   // Allow unit tests access to the private constructor and CreateBridge()
   // method, since unit tests don't have a complete browser (i.e., with a
   // WebContents and RenderFrameHost) to work with.
   friend class CastRemotingConnectorTest;
 
-  // Implementation of the media::mojom::RemoterFactory, with one instance
-  // created per content::RenderFrameHost. An instance of this class is owned by
-  // its mojo message pipe.
-  class FrameRemoterFactory;
-
   // Implementation of the media::mojom::Remoter service for a single source in
   // a render frame. This is just a "lightweight bridge" that delegates calls
   // back-and-forth between a CastRemotingConnector and a
   // media::mojom::RemotingSource. An instance of this class is owned by its
   // mojo message pipe.
   class RemotingBridge;
 
   // A RouteMessageObserver for the remoting route that passes messages from the
   // Cast Provider back to this connector. An instance of this class only exists
   // while a remoting route is available, and is owned by CastRemotingConnector.
@@ skipping 98 matching lines @@
   base::WeakPtrFactory<CastRemotingConnector> weak_factory_;
 
   // Key used with the base::SupportsUserData interface to search for an
   // instance of CastRemotingConnector owned by a WebContents.
   static const void* const kUserDataKey;
 
   DISALLOW_COPY_AND_ASSIGN(CastRemotingConnector);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_CAST_REMOTING_CONNECTOR_H_