Reland of Use spec-compliant algorithm to select video devices in getUserMedia.

content/renderer/media/user_media_client_impl.h

 // Copyright (c) 2012 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_RENDERER_MEDIA_USER_MEDIA_CLIENT_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_USER_MEDIA_CLIENT_IMPL_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 12 matching lines @@
 #include "content/renderer/media/media_stream_source.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebMediaDeviceChangeObserver.h"
 #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h"
 #include "third_party/WebKit/public/web/WebUserMediaClient.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 
+namespace base {
+class TaskRunner;
+}
+
 namespace content {
 class PeerConnectionDependencyFactory;
 class MediaStreamAudioSource;
 class MediaStreamDispatcher;
 class MediaStreamVideoSource;
+struct VideoCaptureSourceSelectionResult;
 
 // UserMediaClientImpl is a delegate for the Media Stream GetUserMedia API.
 // It ties together WebKit and MediaStreamManager
 // (via MediaStreamDispatcher and MediaStreamDispatcherHost)
 // in the browser process. It must be created, called and destroyed on the
 // render thread.
 class CONTENT_EXPORT UserMediaClientImpl
     : public RenderFrameObserver,
       NON_EXPORTED_BASE(public blink::WebUserMediaClient),
       public MediaStreamDispatcherEventHandler,
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
   // |render_frame| and |dependency_factory| must outlive this instance.
   UserMediaClientImpl(
       RenderFrame* render_frame,
       PeerConnectionDependencyFactory* dependency_factory,
-      std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher);
+      std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher,
+      const scoped_refptr<base::TaskRunner>& worker_task_runner);
   ~UserMediaClientImpl() override;
 
   MediaStreamDispatcher* media_stream_dispatcher() const {
     return media_stream_dispatcher_.get();
   }
 
   // blink::WebUserMediaClient implementation
   void requestUserMedia(
       const blink::WebUserMediaRequest& user_media_request) override;
   void cancelUserMediaRequest(
@@ skipping 210 matching lines @@
 
   // Returns true if we do find and remove the |source|.
   // Otherwise returns false.
   bool RemoveLocalSource(const blink::WebMediaStreamSource& source);
 
   void StopLocalSource(const blink::WebMediaStreamSource& source,
                        bool notify_dispatcher);
 
   const ::mojom::MediaDevicesDispatcherHostPtr& GetMediaDevicesDispatcher();
 
-  void SelectUserMediaDevice(
+  struct RequestSettings;
+
+  void SelectAudioInputDevice(
       int request_id,
       const blink::WebUserMediaRequest& user_media_request,
       std::unique_ptr<StreamControls> controls,
-      bool enable_automatic_output_device_selection,
-      const url::Origin& security_origin,
+      const RequestSettings& request_settings,
       const EnumerationResult& device_enumeration);
+
+  void SetupVideoInput(int request_id,
+                       const blink::WebUserMediaRequest& user_media_request,
+                       std::unique_ptr<StreamControls> controls,
+                       const RequestSettings& request_settings);
+
+  void SelectVideoDeviceSourceSettings(
+      int request_id,
+      const blink::WebUserMediaRequest& user_media_request,
+      std::unique_ptr<StreamControls> controls,
+      const RequestSettings& request_settings,
+      std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
+          video_input_capabilities);
+
+  void FinalizeSelectVideoDeviceSourceSettings(
+      int request_id,
+      const blink::WebUserMediaRequest& user_media_request,
+      std::unique_ptr<StreamControls> controls,
+      const RequestSettings& request_settings,
+      const VideoCaptureSourceSelectionResult& selection_result);
+
   void FinalizeRequestUserMedia(
       int request_id,
       const blink::WebUserMediaRequest& user_media_request,
       std::unique_ptr<StreamControls> controls,
-      bool enable_automatic_output_device_selection,
-      const url::Origin& security_origin);
+      const RequestSettings& request_settings);
 
   // Callback invoked by MediaDevicesEventDispatcher when a device-change
   // notification arrives.
   void DevicesChanged(MediaDeviceType device_type,
                       const MediaDeviceInfoArray& device_infos);
 
   // Weak ref to a PeerConnectionDependencyFactory, owned by the RenderThread.
   // It's valid for the lifetime of RenderThread.
   // TODO(xians): Remove this dependency once audio do not need it for local
   // audio.
   PeerConnectionDependencyFactory* const dependency_factory_;
 
   // UserMediaClientImpl owns MediaStreamDispatcher instead of RenderFrameImpl
   // (or RenderFrameObserver) to ensure tear-down occurs in the right order.
   const std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher_;
 
   ::mojom::MediaDevicesDispatcherHostPtr media_devices_dispatcher_;
 
   LocalStreamSources local_sources_;
   LocalStreamSources pending_local_sources_;
 
   UserMediaRequests user_media_requests_;
   MediaDevicesEventDispatcher::SubscriptionIdList
       device_change_subscription_ids_;
 
   blink::WebMediaDeviceChangeObserver media_device_change_observer_;
 
+  const scoped_refptr<base::TaskRunner> worker_task_runner_;
+
   // Note: This member must be the last to ensure all outstanding weak pointers
   // are invalidated first.
   base::WeakPtrFactory<UserMediaClientImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UserMediaClientImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_USER_MEDIA_CLIENT_IMPL_H_