chrome://media-internals: update MediaInternals when devices capabilities are enumerated.

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 99 matching lines @@
 
   dict.SetString(kAudioLogStatusKey, "created");
   dict.SetString("device_id", device_id);
   dict.SetInteger("frames_per_buffer", params.frames_per_buffer());
   dict.SetInteger("sample_rate", params.sample_rate());
   dict.SetInteger("channels", params.channels());
   dict.SetString("channel_layout",
                  ChannelLayoutToString(params.channel_layout()));
   dict.SetString("effects", EffectsToString(params.effects()));
 
-  media_internals_->SendUpdateAndCache(
+  media_internals_->SendUpdateAndCacheAudioStreamKey(
       FormatCacheKey(component_id), kAudioLogUpdateFunction, &dict);
 }
 
 void AudioLogImpl::OnStarted(int component_id) {
   SendSingleStringUpdate(component_id, kAudioLogStatusKey, "started");
 }
 
 void AudioLogImpl::OnStopped(int component_id) {
   SendSingleStringUpdate(component_id, kAudioLogStatusKey, "stopped");
 }
 
 void AudioLogImpl::OnClosed(int component_id) {
   base::DictionaryValue dict;
   StoreComponentMetadata(component_id, &dict);
   dict.SetString(kAudioLogStatusKey, "closed");
-  media_internals_->SendUpdateAndPurgeCache(
+  media_internals_->SendUpdateAndPurgeAudioStreamCache(
       FormatCacheKey(component_id), kAudioLogUpdateFunction, &dict);
 }
 
 void AudioLogImpl::OnError(int component_id) {
   SendSingleStringUpdate(component_id, "error_occurred", "true");
 }
 
 void AudioLogImpl::OnSetVolume(int component_id, double volume) {
   base::DictionaryValue dict;
   StoreComponentMetadata(component_id, &dict);
   dict.SetDouble("volume", volume);
-  media_internals_->SendUpdateAndCache(
+  media_internals_->SendUpdateAndCacheAudioStreamKey(
       FormatCacheKey(component_id), kAudioLogUpdateFunction, &dict);
 }
 
 std::string AudioLogImpl::FormatCacheKey(int component_id) {
   return base::StringPrintf("%d:%d:%d", owner_id_, component_, component_id);
 }
 
 void AudioLogImpl::SendSingleStringUpdate(int component_id,
                                           const std::string& key,
                                           const std::string& value) {
   base::DictionaryValue dict;
   StoreComponentMetadata(component_id, &dict);
   dict.SetString(key, value);
-  media_internals_->SendUpdateAndCache(
+  media_internals_->SendUpdateAndCacheAudioStreamKey(
       FormatCacheKey(component_id), kAudioLogUpdateFunction, &dict);
 }
 
 void AudioLogImpl::StoreComponentMetadata(int component_id,
                                           base::DictionaryValue* dict) {
   dict->SetInteger("owner_id", owner_id_);
   dict->SetInteger("component_id", component_id);
   dict->SetInteger("component_type", component_);
 }
 
@@ skipping 34 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   for (size_t i = 0; i < update_callbacks_.size(); ++i) {
     if (update_callbacks_[i].Equals(callback)) {
       update_callbacks_.erase(update_callbacks_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
-void MediaInternals::SendEverything() {
-  base::string16 everything_update;
+void MediaInternals::SendAudioStreamData() {
+  base::string16 audio_stream_update;
   {
     base::AutoLock auto_lock(lock_);
-    everything_update = SerializeUpdate(
-        "media.onReceiveEverything", &cached_data_);
+    audio_stream_update = SerializeUpdate(
+        "media.onReceiveEverything", &audio_streams_cached_data_);
   }
-  SendUpdate(everything_update);
+  SendUpdate(audio_stream_update);
+}
+
+void MediaInternals::UpdateVideoCaptureDeviceCapabilities(
+    const std::vector<Tuple2<media::VideoCaptureDevice::Name,
+                             media::VideoCaptureFormats> >& name_and_formats) {
+  DCHECK(video_devices_cached_data_.empty());

[perkj_chrome, 2014/10/07 15:51:23]

You dont' need a member variable video_devices_cached_data_?

[mcasas, 2014/10/08 11:31:04]

Done.

+
+  for (const auto &name_and_format : name_and_formats) {
+    base::DictionaryValue* formats_dict = new base::DictionaryValue();
+    formats_dict->SetString("Unique ID", name_and_format.a.id());
+#if defined(OS_WIN) || defined(OS_MACOSX)
+    formats_dict->SetString("Capture API:",
+                            name_and_format.a.capture_api_type());

[burnik, 2014/10/07 14:17:02]

Looks like capture_api_type() is not a string.
You should probably add enum to string conversion method for
media::VideoCaptureDevice::Name::CaptureApiType.

Maybe linux should have this too, but with a single enum value like
"DEFAULT_API" or "NO_API". What do you think?

[mcasas, 2014/10/07 14:54:44]

Yeah, just saw it :)
It's more complex to add the stringify, so I'd print it as
integer, WDYT?

+#endif
+    int cont = 0;
+    for (const auto &format : name_and_format.b) {
+      formats_dict->SetString(base::StringPrintf("[%3d]", cont++),
+                              format.ToString());
+    }
+    video_devices_cached_data_.Set(name_and_format.a.GetNameAndModel(),
+                                   formats_dict);
+  }
+  // TODO(mcasas): Send the capabilities to JS in a similar way to what

[perkj_chrome, 2014/10/07 14:12:51]

remove TODO. It does not belong in here. 

[mcasas, 2014/10/07 14:54:44]

I think it does, since it's to be removed in the next
CL addressing the bug...

[perkj_chrome, 2014/10/07 15:51:23]

I see. I thought this was actually a comment about
MediStreamTrack::capabilities. Ignore this,.

+  // MediaInternals::SendAudioStreamData() does.
+  DVLOG(1) << "Received: " << video_devices_cached_data_;
+
+  video_devices_cached_data_.Clear();

[perkj_chrome, 2014/10/07 14:12:51]

? 

[mcasas, 2014/10/07 14:54:44]

This line goes with the previous TODO comment, IOW
after pinging a la SendAudioStreamData(), we have to
clear the cache -- see l.230.

Perhaps the comment does not make obvious enough this
meta-state after this CL and before the "next" one...
How would you signal that?

[perkj_chrome, 2014/10/07 15:51:23]

TODO remove once.... 

[mcasas, 2014/10/08 11:31:04]

Gone anyway since I moved |video_devices_cached_data_|
to a method-scoped variable, following your previous
comment/remark.

+}
+
+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) {
   // SendUpdate() may be called from any thread, but must run on the IO thread.
   // TODO(dalecurtis): This is pretty silly since the update callbacks simply
   // forward the calls to the UI thread.  We should avoid the extra hop.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
         &MediaInternals::SendUpdate, base::Unretained(this), update));
     return;
   }
 
   for (size_t i = 0; i < update_callbacks_.size(); i++)
     update_callbacks_[i].Run(update);
 }
 
-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::SendUpdateAndCache(const std::string& cache_key,
-                                        const std::string& function,
-                                        const base::DictionaryValue* value) {
+void MediaInternals::SendUpdateAndCacheAudioStreamKey(
+    const std::string& cache_key,
+    const std::string& function,
+    const base::DictionaryValue* value) {
   SendUpdate(SerializeUpdate(function, value));
 
   base::AutoLock auto_lock(lock_);
-  if (!cached_data_.HasKey(cache_key)) {
-    cached_data_.Set(cache_key, value->DeepCopy());
+  if (!audio_streams_cached_data_.HasKey(cache_key)) {
+    audio_streams_cached_data_.Set(cache_key, value->DeepCopy());
     return;
   }
 
   base::DictionaryValue* existing_dict = NULL;
-  CHECK(cached_data_.GetDictionary(cache_key, &existing_dict));
+  CHECK(audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
   existing_dict->MergeDictionary(value);
 }
 
-void MediaInternals::SendUpdateAndPurgeCache(
+void MediaInternals::SendUpdateAndPurgeAudioStreamCache(
     const std::string& cache_key,
     const std::string& function,
     const base::DictionaryValue* value) {
   SendUpdate(SerializeUpdate(function, value));
 
   base::AutoLock auto_lock(lock_);
   scoped_ptr<base::Value> out_value;
-  CHECK(cached_data_.Remove(cache_key, &out_value));
+  CHECK(audio_streams_cached_data_.Remove(cache_key, &out_value));
 }
 
 }  // namespace content