Delete VideoFrameFactory, CapturedFrame, and related code.

webrtc/media/base/fakevideocapturer.h

 /*
  *  Copyright (c) 2004 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.
  */
 
 #ifndef WEBRTC_MEDIA_BASE_FAKEVIDEOCAPTURER_H_
 #define WEBRTC_MEDIA_BASE_FAKEVIDEOCAPTURER_H_
 
 #include <string.h>
 
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/media/base/videocommon.h"
 #include "webrtc/media/base/videoframe.h"
-#ifdef HAVE_WEBRTC_VIDEO
-#include "webrtc/media/engine/webrtcvideoframefactory.h"
-#endif
 
 namespace cricket {
 
 // Fake video capturer that allows the test to manually pump in frames.
 class FakeVideoCapturer : public cricket::VideoCapturer {
  public:
   FakeVideoCapturer(bool is_screencast)
       : running_(false),
         initial_timestamp_(rtc::TimeNanos()),
         next_timestamp_(rtc::kNumNanosecsPerMillisec),
         is_screencast_(is_screencast),
         rotation_(webrtc::kVideoRotation_0) {
-#ifdef HAVE_WEBRTC_VIDEO
-    set_frame_factory(new cricket::WebRtcVideoFrameFactory());
-#endif
     // Default supported formats. Use ResetSupportedFormats to over write.
     std::vector<cricket::VideoFormat> formats;
     formats.push_back(cricket::VideoFormat(1280, 720,
         cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
     formats.push_back(cricket::VideoFormat(640, 480,
         cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
     formats.push_back(cricket::VideoFormat(320, 240,
         cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
     formats.push_back(cricket::VideoFormat(160, 120,
         cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
@@ skipping 35 matching lines @@
     if (fourcc == cricket::FOURCC_ARGB) {
       size = width * 4 * height;
     } else if (fourcc == cricket::FOURCC_I420) {
       size = width * height + 2 * ((width + 1) / 2) * ((height + 1) / 2);
     } else {
       return false;  // Unsupported FOURCC.
     }
     if (size == 0u) {
       return false;  // Width and/or Height were zero.
     }
-
+#if 0
+    // TODO(nisse): Create a cricket::VideoFrame and call OnFrame.
     cricket::CapturedFrame frame;
     frame.width = width;
     frame.height = height;
     frame.fourcc = fourcc;
     frame.data_size = size;
     frame.time_stamp = initial_timestamp_ + next_timestamp_;
     next_timestamp_ += timestamp_interval;
 
     std::unique_ptr<char[]> data(new char[size]);
     frame.data = data.get();
     // Copy something non-zero into the buffer so Validate wont complain that
     // the frame is all duplicate.
     memset(frame.data, 1, size / 2);
     memset(reinterpret_cast<uint8_t*>(frame.data) + (size / 2), 2,
            size - (size / 2));
     memcpy(frame.data, reinterpret_cast<const uint8_t*>(&fourcc), 4);
     frame.rotation = rotation_;
     // TODO(zhurunz): SignalFrameCaptured carry returned value to be able to
     // capture results from downstream.
     SignalFrameCaptured(this, &frame);
+#endif
+    // TODO(nisse): XXX Keep to avoid warning.

[pthatcher1, 2016/08/23 00:13:13]

So are you going to delete this too?

[nisse-webrtc, 2016/08/23 06:46:39]

No, but the #if:ed out block needs to be rewritten to invoke
cricket::VideoCapturer::OnFrame. And write pixel data into an I420Buffer
(VideoFrameBuffer subclass), without going via the cricket::CapturedFrame
struct.

+    next_timestamp_ += timestamp_interval;
+
     return true;
   }
 
-  void SignalCapturedFrame(cricket::CapturedFrame* frame) {
-    SignalFrameCaptured(this, frame);
-  }
-
   sigslot::signal1<FakeVideoCapturer*> SignalDestroyed;
 
   virtual cricket::CaptureState Start(const cricket::VideoFormat& format) {
     cricket::VideoFormat supported;
     if (GetBestCaptureFormat(format, &supported)) {
       SetCaptureFormat(&supported);
     }
     running_ = true;
     SetCaptureState(cricket::CS_RUNNING);
     return cricket::CS_RUNNING;
@@ skipping 21 matching lines @@
   bool running_;
   int64_t initial_timestamp_;
   int64_t next_timestamp_;
   const bool is_screencast_;
   webrtc::VideoRotation rotation_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_FAKEVIDEOCAPTURER_H_