Fix getUserMedia so that failure is reported for invalid audio sources.

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 101 matching lines @@
       const blink::WebString& result_name);
 
   virtual void EnumerateDevicesSucceded(
       blink::WebMediaDevicesRequest* request,
       blink::WebVector<blink::WebMediaDeviceInfo>& devices);
 
   // Creates a MediaStreamAudioSource/MediaStreamVideoSource objects.
   // These are virtual for test purposes.
   virtual MediaStreamAudioSource* CreateAudioSource(
       const StreamDeviceInfo& device,
-      const blink::WebMediaConstraints& constraints);
+      const blink::WebMediaConstraints& constraints,
+      const MediaStreamSource::ConstraintsCallback& source_ready);
   virtual MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback);
 
   // Class for storing information about a WebKit request to create a
   // MediaStream.
   class UserMediaRequestInfo
       : public base::SupportsWeakPtr<UserMediaRequestInfo> {
    public:
     typedef base::Callback<void(UserMediaRequestInfo* request_info,
                                 MediaStreamRequestResult result,
                                 const blink::WebString& result_name)>
       ResourcesReady;
 
     UserMediaRequestInfo(int request_id,
                          const blink::WebUserMediaRequest& request,
                          bool enable_automatic_output_device_selection);
     ~UserMediaRequestInfo();
     int request_id;
     // True if MediaStreamDispatcher has generated the stream, see
     // OnStreamGenerated.
     bool generated;
     const bool enable_automatic_output_device_selection;
     blink::WebMediaStream web_stream;
     blink::WebUserMediaRequest request;
 
-    void StartAudioTrack(const blink::WebMediaStreamTrack& track);
+    void StartAudioTrack(const blink::WebMediaStreamTrack& track,
+                         bool source_initialized);
 
     blink::WebMediaStreamTrack CreateAndStartVideoTrack(
         const blink::WebMediaStreamSource& source,
         const blink::WebMediaConstraints& constraints);
 
     // Triggers |callback| when all sources used in this request have either
     // successfully started, or a source has failed to start.
     void CallbackOnTracksStarted(const ResourcesReady& callback);
 
-    bool IsSourceUsed(const blink::WebMediaStreamSource& source) const;
-    void RemoveSource(const blink::WebMediaStreamSource& source);
+    bool HasPendingSources() const;
 
-    bool HasPendingSources() const;
+    // Called when a local audio source has finished (or failed) initializing.
+    void OnAudioSourceStarted(MediaStreamSource* source,
+                              MediaStreamRequestResult result,
+                              const blink::WebString& result_name);
 
    private:
     void OnTrackStarted(
         MediaStreamSource* source,
         MediaStreamRequestResult result,
         const blink::WebString& result_name);
+
+    // Cheks if the sources for all tracks have been started and if so,
+    // invoke the |ready_callback_|.  Note that the caller should expect
+    // that |this| might be deleted when the function returns.
     void CheckAllTracksStarted();
 
     ResourcesReady ready_callback_;
     MediaStreamRequestResult request_result_;
     blink::WebString request_result_name_;
     // Sources used in this request.
     std::vector<blink::WebMediaStreamSource> sources_;
     std::vector<MediaStreamSource*> sources_waiting_for_callback_;
   };
   typedef ScopedVector<UserMediaRequestInfo> UserMediaRequests;
 
  protected:
   // These methods can be accessed in unit tests.
   UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id);
   UserMediaRequestInfo* FindUserMediaRequestInfo(
       const blink::WebUserMediaRequest& request);
 
   void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request);
 
  private:
   typedef std::vector<blink::WebMediaStreamSource> LocalStreamSources;
 
   // RenderFrameObserver implementation.
   void OnDestruct() override;
 
   // Creates a WebKit representation of stream sources based on
   // |devices| from the MediaStreamDispatcher.
-  void InitializeSourceObject(
+  void InitializeVideoSourceObject(
       const StreamDeviceInfo& device,
-      blink::WebMediaStreamSource::Type type,
       const blink::WebMediaConstraints& constraints,
       blink::WebMediaStreamSource* webkit_source);
 
+  void InitializeAudioSourceObject(

[miu, 2017/01/11 20:51:11]

Please return a bool instead of make the caller provide a separate output
argument. (Discussed further in .cc file comments.) Also, suggest you use
WARN_UNUSED_RESULT to make sure code acts on this bool.

[tommi (sloooow) - chröme, 2017/01/11 22:40:59]

Done.  Also changed InitializeVideoSourceObject to follow the same convention.

However, I can't return bool since that would indicate whether or not the
function failed to do its job. I realize this is a misunderstanding because I
chose a poor variable name for |source_initialized|.  Instead I've renamed that
variable to |is_pending| and reversed how it's used.

+      const StreamDeviceInfo& device,
+      const blink::WebMediaConstraints& constraints,
+      blink::WebMediaStreamSource* webkit_source,
+      bool* source_initialized);
+
   void CreateVideoTracks(
       const StreamDeviceInfoArray& devices,
       const blink::WebMediaConstraints& constraints,
       blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
       UserMediaRequestInfo* request);
 
   void CreateAudioTracks(
       const StreamDeviceInfoArray& devices,
       const blink::WebMediaConstraints& constraints,
       blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
       UserMediaRequestInfo* request);
 
   // Callback function triggered when all native versions of the
   // underlying media sources and tracks have been created and started.
   void OnCreateNativeTracksCompleted(
       UserMediaRequestInfo* request,
       MediaStreamRequestResult result,
       const blink::WebString& result_name);
 
   void OnStreamGeneratedForCancelledRequest(
       const StreamDeviceInfoArray& audio_array,
       const StreamDeviceInfoArray& video_array);
 
+  static void OnAudioSourceStartedOnAudioThread(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      base::WeakPtr<UserMediaClientImpl> weak_ptr,
+      MediaStreamSource* source,
+      MediaStreamRequestResult result,
+      const blink::WebString& result_name);
+
+  void OnAudioSourceStarted(MediaStreamSource* source,
+                            MediaStreamRequestResult result,
+                            const blink::WebString& result_name);
+
   using EnumerationResult = std::vector<MediaDeviceInfoArray>;
   void FinalizeEnumerateDevices(blink::WebMediaDevicesRequest request,
                                 const EnumerationResult& result);
 
   void DeleteAllUserMediaRequests();
 
   // Returns the source that use a device with |device.session_id|
   // and |device.device.id|. NULL if such source doesn't exist.
   const blink::WebMediaStreamSource* FindLocalSource(
+      const StreamDeviceInfo& device) const {
+    return FindLocalSource(local_sources_, device);
+  }
+  const blink::WebMediaStreamSource* FindPendingLocalSource(
+      const StreamDeviceInfo& device) const {
+    return FindLocalSource(pending_local_sources_, device);
+  }
+  const blink::WebMediaStreamSource* FindLocalSource(
+      const LocalStreamSources& sources,
       const StreamDeviceInfo& device) const;
 
+  // Looks up a local source and returns it if found. If not found, prepares
+  // a new WebMediaStreamSource with a NULL extraData pointer.
+  blink::WebMediaStreamSource FindOrInitializeSourceObject(
+      const StreamDeviceInfo& device);
+
   // 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(
@@ skipping 21 matching lines @@
   // 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_;
 
   // 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_