Pass camera facing info to audio client

content/browser/renderer_host/media/media_stream_manager.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.
 
 // MediaStreamManager is used to open media capture devices (video supported
 // now). Call flow:
 // 1. GenerateStream is called when a render process wants to use a capture
 //    device.
 // 2. MediaStreamManager will ask MediaStreamUIController for permission to
 //    use devices and for which device to use.
@@ skipping 27 matching lines @@
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_observer.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/media_devices_manager.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/common/content_export.h"
 #include "content/common/media/media_devices.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/media_request_state.h"
+#include "media/base/video_facing.h"
 
 namespace media {
 class AudioManager;
 }
 
 namespace url {
 class Origin;
 }
 
 namespace content {
@@ skipping 32 matching lines @@
 
   // Used to access VideoCaptureManager.
   VideoCaptureManager* video_capture_manager();
 
   // Used to access AudioInputDeviceManager.
   AudioInputDeviceManager* audio_input_device_manager();
 
   // Used to access MediaDevicesManager.
   MediaDevicesManager* media_devices_manager();
 
+  void SetVideoCaptureObserver(media::VideoCaptureObserver* capture_observer);

[chfremer1, 2017/01/25 18:13:44]

I recommend that we indicate to the reader that this method is part of the
construction+configuration interface of MediaStreamManager, as opposed to the
interface intended for "usage by its regular clients". 

In my opinion, the cleanest way to express this in C++ would be to explicitly
define and expose an interface containing only the methods that are intended for
"usage by regular clients", and SetVideoCaptureObserver() would probably not be
a part of that. This approach has the extra advantage of allowing us to easily
mock out MediaStreamManager when testing its clients.

If that is too much work, the "cheap" way would be to express this information
in a comment.

Either way, we should express the following information to the reader:
* At what time of the lifecycle of MediaStreamManager is it legal to call this
method.
* On what thread would it need to be called (probably the same as the
constructor?)
* Is it legal to call it more than once? Potentially setting |capture_observer|
back to nullptr? (This would be useful for clients who cannot guarantee that
|capture_observer| outlives the MediaStreamManager instance.)
* Is it legal to not call it at all?
* On what thread will the callbacks to |capture_observer| arrive?

[shenghao, 2017/01/29 10:21:01]

Done.

+
   // Creates a new media access request which is identified by a unique string
   // that's returned to the caller. This will trigger the infobar and ask users
   // for access to the device. |render_process_id| and |render_frame_id| are
   // used to determine where the infobar will appear to the user. |callback| is
   // used to send the selected device to the clients. An empty list of device
   // will be returned if the users deny the access.
   std::string MakeMediaAccessRequest(
       int render_process_id,
       int render_frame_id,
       int page_request_id,
@@ skipping 297 matching lines @@
   std::map<int, base::Callback<void(const std::string&)>> log_callbacks_;
 
   GenerateStreamTestCallback generate_stream_test_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_