Video Capture Capabilities available on chrome://media-internals

content/browser/media/media_internals.cc

 // 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 "content/browser/media/media_internals.h"
 
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 206 matching lines @@
 void MediaInternals::SendAudioStreamData() {
   base::string16 audio_stream_update;
   {
     base::AutoLock auto_lock(lock_);
     audio_stream_update = SerializeUpdate(
         "media.onReceiveAudioStreamData", &audio_streams_cached_data_);
   }
   SendUpdate(audio_stream_update);
 }
 
+void MediaInternals::SendVideoCaptureCapabilities() {
+  base::string16 video_capture_capabilities_update;
+  {
+    base::AutoLock auto_lock(lock_);
+    video_capture_capabilities_update = SerializeUpdate(
+        "media.onReceiveVideoCaptureCapabilities",
+        &video_capture_capabilities_cached_data_);
+  }
+  SendUpdate(video_capture_capabilities_update);
+}
+
 void MediaInternals::UpdateVideoCaptureDeviceCapabilities(
     const media::VideoCaptureDeviceInfos& video_capture_device_infos) {

[perkj_chrome, 2014/10/15 15:05:16]

isn't this on io too. In that case- add DCHECKS for that and remove the use of
lock.

[burnik, 2014/10/15 15:43:13]

Done.

-  base::DictionaryValue video_devices_info_dictionary;
 
-  for (const auto& video_capture_device_info : video_capture_device_infos) {
-    base::DictionaryValue* formats_dict = new base::DictionaryValue();
-    formats_dict->SetString("Unique ID", video_capture_device_info.name.id());
+  {
+    base::AutoLock auto_lock(lock_);

[perkj_chrome, 2014/10/15 15:05:16]

why is a lock needed? What thread is this and what thread are you protecting
against. You should be able to post this to the right thread instead.

[burnik, 2014/10/15 15:43:13]

You're right. I forgot the fact that both device enumeration and callbacks from
JS live on the IO thread.

+    video_capture_capabilities_cached_data_.Clear();
+
+    for (const auto& video_capture_device_info : video_capture_device_infos) {
+      base::ListValue* format_list = new base::ListValue();
+      for (const auto& format : video_capture_device_info.supported_formats)
+        format_list->AppendString(format.ToString());
+
+      base::DictionaryValue* device_dict = new base::DictionaryValue();
+      device_dict->SetString("id", video_capture_device_info.name.id());
+      device_dict->SetString(
+          "name", video_capture_device_info.name.GetNameAndModel());
+      device_dict->Set("formats", format_list);
 #if defined(OS_WIN) || defined(OS_MACOSX)
-    formats_dict->SetInteger("Capture API: #",
-                             video_capture_device_info.name.capture_api_type());
+      device_dict->SetInteger(
+          "captureApi",
+          video_capture_device_info.name.capture_api_type());
 #endif
-    int count = 0;
-    for (const auto& format : video_capture_device_info.supported_formats) {
-      formats_dict->SetString(base::StringPrintf("[%3d]", count++),
-                              format.ToString());
+      video_capture_capabilities_cached_data_.Append(device_dict);
     }
-    video_devices_info_dictionary.Set(
-        video_capture_device_info.name.GetNameAndModel(), formats_dict);
   }
-  // TODO(mcasas): Remove the following printout when sending the capabilities
-  // to JS is implemented in a similar way to how SendAudioStreamData() does.
-  // A lock might be needed if these capabilities are cached at this point.
-  DVLOG(1) << "Received: " << video_devices_info_dictionary;
+
+  SendVideoCaptureCapabilities();
 }
 
 scoped_ptr<media::AudioLog> MediaInternals::CreateAudioLog(
     AudioComponent component) {
   base::AutoLock auto_lock(lock_);
   return scoped_ptr<media::AudioLog>(new AudioLogImpl(
       owner_ids_[component]++, component, this));
 }
 
 void MediaInternals::SendUpdate(const base::string16& update) {
@@ skipping 32 matching lines @@
     const std::string& function,
     const base::DictionaryValue* value) {
   SendUpdate(SerializeUpdate(function, value));
 
   base::AutoLock auto_lock(lock_);
   scoped_ptr<base::Value> out_value;
   CHECK(audio_streams_cached_data_.Remove(cache_key, &out_value));
 }
 
 }  // namespace content