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

content/browser/media/media_internals_unittest.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
@@ skipping 13 matching lines @@
 class MediaInternalsTestBase {
  public:
   MediaInternalsTestBase()
     : media_internals_(content::MediaInternals::GetInstance()) {
   }
   virtual ~MediaInternalsTestBase() {}
 
  protected:
   // Extracts and deserializes the JSON update data; merges into |update_data_|.
   void UpdateCallbackImpl(const base::string16& update) {
-    // Each update string looks like "<JavaScript Function Name>({<JSON>});", to
-    // use the JSON reader we need to strip out the JavaScript code.
+    // Each update string looks like "<JavaScript Function Name>({<JSON>});"
+    // or for video capabilities: "<JavaScript Function Name>([{<JSON>}]);".

[mcasas, 2014/10/15 13:54:42]

<JavaScript Function Name>([{<JSON>}]);
is repeated.

[burnik, 2014/10/15 14:21:57]

Look more closely.

+    // In the second case we will be able to extract the dictionary if it is the
+    // only member of the list.
+    // To use the JSON reader we need to strip out the JS function name and ().
     std::string utf8_update = base::UTF16ToUTF8(update);
     const std::string::size_type first_brace = utf8_update.find('{');
     const std::string::size_type last_brace = utf8_update.rfind('}');
     scoped_ptr<base::Value> output_value(base::JSONReader::Read(
         utf8_update.substr(first_brace, last_brace - first_brace + 1)));
     CHECK(output_value);
 
     base::DictionaryValue* output_dict = NULL;
     CHECK(output_value->GetAsDictionary(&output_dict));
     update_data_.MergeDictionary(output_dict);
   }
 
   void ExpectInt(const std::string& key, int expected_value) const {
     int actual_value = 0;
     ASSERT_TRUE(update_data_.GetInteger(key, &actual_value));
     EXPECT_EQ(expected_value, actual_value);
   }
 
   void ExpectString(const std::string& key,
                     const std::string& expected_value) const {
     std::string actual_value;
     ASSERT_TRUE(update_data_.GetString(key, &actual_value));
     EXPECT_EQ(expected_value, actual_value);
   }
 
   void ExpectStatus(const std::string& expected_value) const {
     ExpectString("status", expected_value);
   }
 
+  void ExpectListOfStrings(const std::string& key,
+                           base::ListValue * expected_list){

[mcasas, 2014/10/15 13:54:42]

const base::ListValue& ?
Also, method const.

[burnik, 2014/10/15 14:21:57]

Done.

+    base::ListValue * actual_list;
+    ASSERT_TRUE(update_data_.GetList(key, &actual_list));
+    const size_t expected_size = expected_list->GetSize();
+    const size_t actual_size = actual_list->GetSize();
+    ASSERT_EQ(expected_size, actual_size);
+    for (size_t i = 0; i < expected_size; ++i) {
+      std::string expected_value, actual_value;
+      ASSERT_TRUE(expected_list->GetString(i, &expected_value));
+      ASSERT_TRUE(actual_list->GetString(i, &actual_value));
+      EXPECT_EQ(expected_value, actual_value);
+    }
+  }
+
   const content::TestBrowserThreadBundle thread_bundle_;
   base::DictionaryValue update_data_;
   content::MediaInternals* const media_internals_;
 };
 
 }  // namespace
 
 namespace content {
 
 class MediaInternalsVideoCaptureDeviceTest : public testing::Test,
-                                             public MediaInternalsTestBase {};
+                                             public MediaInternalsTestBase {
+ public:
+  MediaInternalsVideoCaptureDeviceTest() :
+    update_cb_(base::Bind(
+        &MediaInternalsVideoCaptureDeviceTest::UpdateCallbackImpl,
+        base::Unretained(this))) {
+      media_internals_->AddUpdateCallback(update_cb_);
+  }
+
+  virtual ~MediaInternalsVideoCaptureDeviceTest() {
+    media_internals_->RemoveUpdateCallback(update_cb_);
+  }
+
+ protected:
+  MediaInternals::UpdateCallback update_cb_;
+};
 
 TEST_F(MediaInternalsVideoCaptureDeviceTest,
-    NotifyVideoCaptureDeviceCapabilitiesEnumerated) {
+       NotifyVideoCaptureDeviceCapabilitiesEnumerated) {
   const int kWidth = 1280;
   const int kHeight = 720;
   const float kFrameRate = 30.0f;
   const media::VideoPixelFormat kPixelFormat = media::PIXEL_FORMAT_I420;
   const media::VideoCaptureFormat format_hd({kWidth, kHeight},
       kFrameRate, kPixelFormat);
   media::VideoCaptureFormats formats{};
   formats.push_back(format_hd);
   const media::VideoCaptureDeviceInfo device_info(
 #if defined(OS_MACOSX)
       media::VideoCaptureDevice::Name("dummy", "dummy",
           media::VideoCaptureDevice::Name::QTKIT),
 #elif defined(OS_WIN)
       media::VideoCaptureDevice::Name("dummy", "dummy",
           media::VideoCaptureDevice::Name::DIRECT_SHOW),
 #elif defined(OS_LINUX) || defined(OS_CHROMEOS)
       media::VideoCaptureDevice::Name("dummy", "/dev/dummy"),
 #else
       media::VideoCaptureDevice::Name("dummy", "dummy"),
 #endif
       formats);
   media::VideoCaptureDeviceInfos device_infos{};
   device_infos.push_back(device_info);
 
-  // TODO(mcasas): Listen for the serialised version of |device_infos| and
-  // check its content using ExpectInt(), ExpectString(), after RunUntilIdle().
+  // When updating video capture capabilities, the update will serialize
+  // a JSON array of objects to string. So here, the |UpdateCallbackImpl| will
+  // deserialize the first object in the array. This means we have to have
+  // exactly one device_info in the |device_infos|.
   media_internals_->UpdateVideoCaptureDeviceCapabilities(device_infos);
   base::RunLoop().RunUntilIdle();
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  ExpectString("id", "/dev/dummy");
+#else
+  ExpectString("id", "dummy");
+#endif
+  ExpectString("name", "dummy");
+  scoped_ptr<base::ListValue> expected_list(new base::ListValue());
+  expected_list->AppendString(
+      "resolution: 1280x720, fps: 30.000000, pixel format: I420");

[mcasas, 2014/10/15 13:54:42]

Prefer to compose this on the fly calling format_hd->ToString().

[burnik, 2014/10/15 14:21:57]

Done.

+  ExpectListOfStrings("formats", expected_list.get());
+#if defined(OS_MACOSX)
+  ExpectInteger("captureApi", media::VideoCaptureDevice::Name::QTKIT);
+#elif defined(OS_WIN)
+  ExpectInteger("captureApi", media::VideoCaptureDevice::Name::DIRECT_SHOW);
+#endif
 }
 
 class MediaInternalsAudioLogTest
     : public MediaInternalsTestBase,
       public testing::TestWithParam<media::AudioLogFactory::AudioComponent> {
  public:
   MediaInternalsAudioLogTest() :
       update_cb_(base::Bind(&MediaInternalsAudioLogTest::UpdateCallbackImpl,
                             base::Unretained(this))),
       test_params_(media::AudioParameters::AUDIO_PCM_LINEAR,
@@ skipping 68 matching lines @@
   ExpectStatus("closed");
 }
 
 INSTANTIATE_TEST_CASE_P(
     MediaInternalsAudioLogTest, MediaInternalsAudioLogTest, testing::Values(
         media::AudioLogFactory::AUDIO_INPUT_CONTROLLER,
         media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER,
         media::AudioLogFactory::AUDIO_OUTPUT_STREAM));
 
 }  // namespace content