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 196 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() {

[burnik, 2014/10/05 23:08:55]

This is a bit unrelated at this point, but it should go away - e.g. renamed to
"SendAudioStreamData".

[mcasas, 2014/10/07 11:25:39]

Done and cleaned up the "audio" parts of this class
so it's explicit what they do.

   base::string16 everything_update;
   {
     base::AutoLock auto_lock(lock_);
     everything_update = SerializeUpdate(
-        "media.onReceiveEverything", &cached_data_);
+        "media.onReceiveEverything", &audio_streams_cached_data_);

[burnik, 2014/10/05 23:08:55]

Audio data is not everything.
Not your doing, but "Everything" is a terrible way of refering to anything. :-D

[mcasas, 2014/10/07 11:25:39]

Done.

   }
   SendUpdate(everything_update);
 }
 
 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(
@@ skipping 11 matching lines @@
   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) {
   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(
     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));
+}
+
+void MediaInternals::UpdateVideoCaptureDeviceCapabilities(
+    const media::VideoCaptureDevice::Name& name,
+    const media::VideoCaptureFormats& formats) {

[burnik, 2014/10/05 23:08:55]

ditto, add:
const size_t num_devices

[mcasas, 2014/10/07 11:25:39]

Done.

+  base::DictionaryValue* formats_dict = new base::DictionaryValue();
+  int cont = 0;
+  for (const auto &it : formats)
+    formats_dict->SetString(base::StringPrintf("[%3d]", cont++), it.ToString());
+  formats_dict->SetString("Unique ID", name.id());
+#if defined(OS_WIN) || defined(OS_MACOSX)
+  formats_dict->SetString("Capture API:", name.capture_api_type());
+#endif
+
+  video_devices_cached_data_.Set(name.GetNameAndModel(), formats_dict);
+  SendEverything();

[burnik, 2014/10/05 23:08:55]

Two problems lie here:
1) You're calling MediaInternals::UpdateVideoCaptureDeviceCapabilities
asynchronously from the VideoCaptureManager for each device enumerated which is
fine until this line. Each update should not send the entire dictionary (up to
that point) for each device enumerated.
2) SendEverything() sends only the audio stream dictionary.

You should check if everything was enumerated and then send the whole dictionary
of video devices.

So here you would check and send:
if (video_devices_cached_data_.size() == num_devices) {
 SendVideoCapabilitiesAndPurgeCache(); // There should be a separate event for
video devices.
}

Also you could DCHECK to make sure Purge was done before enumeration was
started.
DCHECK_LE(video_devices_cached_data_.size(), num_devices);

[mcasas, 2014/10/07 11:25:40]

Done.

+}
+
+void MediaInternals::PurgeVideoCaptureDeviceCapabilities() {

[burnik, 2014/10/05 23:08:55]

We can probably avoid this method alltogether if we had
SendVideoCapabilitiesAndPurgeCache().

[mcasas, 2014/10/07 11:25:39]

Done.

+  video_devices_cached_data_.Clear();
 }
 
 }  // namespace content