Expose Ivf logging through the native API

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
 #include <list>
 #include <map>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
+#include "webrtc/base/file.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
@@ skipping 13 matching lines @@
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/frame_generator_capturer.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 #include "webrtc/test/rtp_rtcp_observer.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video_encoder.h"
 
+#if defined(WEBRTC_WIN)
+#include "webrtc/base/win32.h"
+#else
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
 namespace webrtc {
 
 static const int kSilenceTimeoutMs = 2000;
 
 class EndToEndTest : public test::CallTest {
  public:
   EndToEndTest() {}
 
   virtual ~EndToEndTest() {
     EXPECT_EQ(nullptr, video_send_stream_);
@@ skipping 3668 matching lines @@
 
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
+
+class EndToEndLogTest : public EndToEndTest {
+  void SetUp() { paths_.clear(); }
+  void TearDown() {
+    for (const auto& path : paths_) {
+#if defined(WEBRTC_WIN)
+      ::DeleteFile(rtc::ToUtf16(path).c_str());
+#else
+      ::unlink(path.c_str());
+#endif

[sprang_webrtc, 2016/09/04 14:48:47]

Can we add this as a static delete method to File instead?

+    }
+  }
+
+ public:
+  int AddFile() {
+    paths_.push_back(test::TempFilename(test::OutputPath(), "test_file"));
+    return paths_.size() - 1;
+  }
+
+  rtc::PlatformFile OpenFile(int idx) {
+#if defined(WEBRTC_WIN)
+    return ::CreateFile(rtc::ToUtf16(paths_[idx]).c_str(),
+                        GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING,
+                        FILE_ATTRIBUTE_NORMAL, nullptr);
+#else
+    return ::open(paths_[idx].c_str(), O_RDWR);
+#endif

[sprang_webrtc, 2016/09/04 14:48:47]

Maybe even add this to File itself?

[palmkvist, 2016/09/05 11:57:37]

Thinking about it, platform_file seems like a more reasonable place to put it.
Adding it there, unless someone complains.

+  }
+
+  void LogSend(bool open) {
+    if (open)
+      video_send_stream_->SetLogFiles(OpenFile(AddFile()));
+    else
+      video_send_stream_->SetLogFiles();

[sprang_webrtc, 2016/09/04 14:48:47]

use brackets for if/else

+  }
+  void LogReceive(bool open) {
+    if (open)
+      video_receive_streams_[0]->SetLogFile(OpenFile(AddFile()));
+    else
+      video_receive_streams_[0]->SetLogFile();
+  }
+
+  std::vector<std::string> paths_;
+};
+
+TEST_F(EndToEndLogTest, LogsEncodedFramesWhenRequested) {
+  static const int kNumFramesToRecord = 10;
+  class LogEncodingObserver : public test::EndToEndTest,
+                              public EncodedFrameObserver {
+   public:
+    explicit LogEncodingObserver(EndToEndLogTest* fixture)
+        : EndToEndTest(kDefaultTimeoutMs), fixture_(fixture) {}
+
+    void PerformTest() override {
+      fixture_->LogSend(true);
+      fixture_->LogReceive(true);
+      ASSERT_TRUE(Wait()) << "Timed out while waiting for frame logging.";
+    }
+
+    void ModifyVideoConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8));
+      decoder_.reset(VP8Decoder::Create());
+
+      send_config->post_encode_callback = this;
+      send_config->encoder_settings.payload_name = "VP8";
+      send_config->encoder_settings.encoder = encoder_.get();
+
+      (*receive_configs)[0].decoders.resize(1);
+      (*receive_configs)[0].decoders[0].payload_type =
+          send_config->encoder_settings.payload_type;
+      (*receive_configs)[0].decoders[0].payload_name =
+          send_config->encoder_settings.payload_name;
+      (*receive_configs)[0].decoders[0].decoder = decoder_.get();
+    }
+
+    void EncodedFrameCallback(const EncodedFrame& encoded_frame) override {
+      rtc::CritScope lock(&crit_);
+      if (recorded_frames_++ > kNumFramesToRecord) {
+        fixture_->LogSend(false);
+        fixture_->LogReceive(false);
+        rtc::File send_file(fixture_->OpenFile(0));
+        rtc::File receive_file(fixture_->OpenFile(1));
+        uint8_t out[100];
+        EXPECT_LT(0u, receive_file.Read(out, 100));

[sprang_webrtc, 2016/09/04 14:48:47]

Please add some comments about the intentions here.

+        observation_complete_.Set();
+      }
+    }
+
+   private:
+    EndToEndLogTest* fixture_;

[sprang_webrtc, 2016/09/04 14:48:48]

EndToEndLogTest* const fixture_;

+    std::unique_ptr<VideoEncoder> encoder_;
+    std::unique_ptr<VideoDecoder> decoder_;
+    rtc::CriticalSection crit_;
+    int recorded_frames_ GUARDED_BY(crit_) = 0;

[sprang_webrtc, 2016/09/04 14:48:47]

prefer setting values in the initializer list

+  } test(this);
+
+  RunBaseTest(&test);
+}
+
 }  // namespace webrtc