Improve video capture columns in 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"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size.h"
 
 namespace {
 const int kTestComponentID = 0;
 const char kTestDeviceID[] = "test-device-id";
 
 // This class encapsulates a MediaInternals reference. It also has some useful
 // methods to receive a callback, deserialize its associated data and expect
 // integer/string values.
 class MediaInternalsTestBase {
  public:
@@ skipping 74 matching lines @@
   }
 
   virtual ~MediaInternalsVideoCaptureDeviceTest() {
     media_internals_->RemoveUpdateCallback(update_cb_);
   }
 
  protected:
   MediaInternals::UpdateCallback update_cb_;
 };
 
+#if defined(OS_WIN) || defined(OS_MACOSX)
+TEST_F(MediaInternalsVideoCaptureDeviceTest,
+       AllCaptureApiTypesHaveProperStringRepresentation) {
+  typedef media::VideoCaptureDevice::Name VideoCaptureDeviceName;
+  typedef std::map<VideoCaptureDeviceName::CaptureApiType, std::string>
+      CaptureApiTypeStringMap;
+  CaptureApiTypeStringMap m;
+#if defined(OS_WIN)
+  m[VideoCaptureDeviceName::MEDIA_FOUNDATION] = "MEDIA_FOUNDATION";
+  m[VideoCaptureDeviceName::DIRECT_SHOW] = "DIRECT_SHOW";
+  m[VideoCaptureDeviceName::DIRECT_SHOW_WDM_CROSSBAR] =
+      "DIRECT_SHOW_WDM_CROSSBAR";

[xhwang, 2014/10/21 19:07:49]

Since these are strings, does it make sense to make them more reader friendly,
e.g. s/DIRECT_SHOW/Direct Show/ ?

[burnik, 2014/10/21 19:37:11]

Done.

+#elif defined(OS_MACOSX)
+  m[VideoCaptureDeviceName::AVFOUNDATION] = "AVFOUNDATION";
+  m[VideoCaptureDeviceName::QTKIT] = "QTKIT";
+  m[VideoCaptureDeviceName::DECKLINK] = "DECKLINK";
+#endif
+  EXPECT_EQ(media::VideoCaptureDevice::Name::API_TYPE_UNKNOWN, m.size());
+  for (CaptureApiTypeStringMap::iterator it = m.begin(); it != m.end(); ++it) {
+    const VideoCaptureDeviceName device_name("dummy", "dummy", it->first);
+    EXPECT_EQ(it->second, device_name.GetCaptureApiTypeString());
+  }
+}
+#endif
+
+TEST_F(MediaInternalsVideoCaptureDeviceTest,
+       VideoCaptureFormatStringIsInExpectedFormat) {
+  // Since media internals will send video capture capabilities to JavaScript in
+  // an expected format and there are no public methods for accessing the
+  // resolutions, frame rates or pixel formats, this test checks that the format
+  // has not changed. If the test fails because of the changed format, it should
+  // be updated at the same time as the media internals JS files.
+  const float kFrameRate = 30.0f;
+  const gfx::Size kFrameSize(1280, 720);
+  const media::VideoPixelFormat kPixelFormat = media::PIXEL_FORMAT_I420;
+  const media::VideoCaptureFormat capture_format(
+      kFrameSize, kFrameRate, kPixelFormat);
+  const std::string expected_string =
+      base::StringPrintf("resolution: %s, fps: %f, pixel format: %s",
+                         kFrameSize.ToString().c_str(),
+                         kFrameRate,
+                         media::VideoCaptureFormat::PixelFormatToString(
+                              kPixelFormat).c_str());
+  EXPECT_EQ(expected_string, capture_format.ToString());
+}
+
 TEST_F(MediaInternalsVideoCaptureDeviceTest,
        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);
@@ skipping 22 matching lines @@
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
   ExpectString("id", "/dev/dummy");
 #else
   ExpectString("id", "dummy");
 #endif
   ExpectString("name", "dummy");
   base::ListValue expected_list;
   expected_list.AppendString(format_hd.ToString());
   ExpectListOfStrings("formats", expected_list);
 #if defined(OS_MACOSX)
-  ExpectInt("captureApi", media::VideoCaptureDevice::Name::QTKIT);
+  ExpectString("captureApi", "QTKIT");
 #elif defined(OS_WIN)
-  ExpectInt("captureApi", media::VideoCaptureDevice::Name::DIRECT_SHOW);
+  ExpectString("captureApi", "DIRECT_SHOW");
 #endif
 }
 
 class MediaInternalsAudioLogTest
     : public MediaInternalsTestBase,
       public testing::TestWithParam<media::AudioLogFactory::AudioComponent> {
  public:
   MediaInternalsAudioLogTest() :
       update_cb_(base::Bind(&MediaInternalsAudioLogTest::UpdateCallbackImpl,
                             base::Unretained(this))),
@@ skipping 69 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