Report if video capturing meets output protection requirement.

content/common/media/video_capture_messages.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.
 
 #include "base/memory/shared_memory.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "content/public/common/common_param_traits.h"
+#include "content/public/common/media_stream_request.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 #undef IPC_MESSAGE_EXPORT
 #define IPC_MESSAGE_EXPORT CONTENT_EXPORT
 #define IPC_MESSAGE_START VideoCaptureMsgStart
 
 IPC_ENUM_TRAITS_MAX_VALUE(content::VideoCaptureState,
@@ skipping 90 matching lines @@
 
 // Requests that the video capturer send a frame "soon" (e.g., to resolve
 // picture loss or quality issues).
 IPC_MESSAGE_CONTROL1(VideoCaptureHostMsg_RequestRefreshFrame,
                      int /* device_id */)
 
 // Close the video capture specified by |device_id|.
 IPC_MESSAGE_CONTROL1(VideoCaptureHostMsg_Stop,
                      int /* device_id */)
 
+// Tell the browser process if the video capture is secure (i.e., all
+// connected video sinks meet the requirement of output protection.).
+IPC_MESSAGE_CONTROL3(VideoCaptureHostMsg_SetCapturingLinkSecured,

[miu, 2016/04/26 01:25:13]

Hmm...It seems like this should be a MediaStreamHostMsg instead (in
content/common/media/media_stream_messages.h).  Having VideoCaptureHost worry
about MediaStreamTypes feels like an abstraction violation.

[xjz, 2016/04/29 00:11:42]

The reason to use MediaStreamType here is that the |session_id| is unique only
for the same MediaStreamType. Now changed to use device id, which should also
work. 

[miu, 2016/05/02 21:02:45]

I should have explained more clearly before: What I'm concerned about is the
encapsulation of responsibilities/functionality here. MediaStreamManager is
responsible for managing control and permissions for the streams (and
bubbling-up metadata/state to the embedder), whereas VideoCaptureHost is only
supposed to be responsible for delivering video frames across browser-->renderer
process. More specifically:

1. The code you added in VideoCaptureHost has to call into MediaStreamManager
directly anyway. In other words, VideoCaptureHost doesn't seem to need to be
involved in propagating this signal, but MediaStreamManager does.

2. The MediaObserver, which you use to propagate the secure link signal to the
embedder (i.e., the code in src/chrome/...), is something only
MediaStreamManager knows about.

3. The secure link state is "control/permissions metadata management," and not
related to video frame delivery. MediaStreamManager seems to be a more
appropriate handler for this information.

It should be relatively simple to migrate the IPC messaging in this change:

1. Just rename VideoCaptureHostMsg_SetCapturingLinkSecured to
MediaStreamHostMsg_SetCapturingLinkSecured, and put it in
media_stream_messages.h; and the use of MediaStreamType+session_id would be
reasonable here.

2. Have MediaStreamDispatcherHost handle the IPC message (browser-side) rather
than VideoCaptureHost.

3. LocalVideoCapturerSource (in the render process) can send the IPC to the
browser process via MediaStreamDispatcher: First, you'll need to plumb-in access
to the RenderFrameImpl instance from the LocalVideoCapturerSource by passing
render_frame() in the constructor call from here:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...
LocalVideoCapturerSource should extend RenderFrameObserver to always be sure the
pointer to the RenderFrameImpl is valid before trying to call: if
(render_frame()) render_frame()->GetMediaStreamDispatcher()->Send(new
MediaStreamHostMsg_...) If this is a bit confusing, feel free to stop by my
desk, and I can explain how RenderFrameImpl works in more detail.

[xjz, 2016/05/04 18:23:48]

Thanks for the clear explanation! Changed the IPC message to MediaStreamHostMsg.

+                     content::MediaStreamType, /* type */
+                     int,                      /* session_id */
+                     bool /* is_secure */)
+
 // Tell the browser process that the renderer has finished reading from
 // a buffer previously delivered by VideoCaptureMsg_BufferReady.
 IPC_MESSAGE_CONTROL4(VideoCaptureHostMsg_BufferReady,
                      int /* device_id */,
                      int /* buffer_id */,
                      gpu::SyncToken /* sync_token */,
                      double /* consumer_resource_utilization */)
 
 // Get the formats supported by a device referenced by |capture_session_id|.
 IPC_MESSAGE_CONTROL2(VideoCaptureHostMsg_GetDeviceSupportedFormats,
                      int /* device_id */,
                      media::VideoCaptureSessionId /* session_id */)
 
 // Get the format(s) in use by a device referenced by |capture_session_id|.
 IPC_MESSAGE_CONTROL2(VideoCaptureHostMsg_GetDeviceFormatsInUse,
                      int /* device_id */,
                      media::VideoCaptureSessionId /* session_id */)