Deletes the class VideoRendererCallback.

webrtc/modules/video_render/video_render_impl.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 139 matching lines @@
                  kTraceVideoRenderer,
                  _id,
                  "%s: stream doesn't exist",
                  __FUNCTION__);
     return 0;
   }
   assert(it->second != NULL);
   return it->second->IncomingRate();
 }
 
-VideoRenderCallback*
+rtc::VideoSinkInterface<VideoFrame>*
 ModuleVideoRenderImpl::AddIncomingRenderStream(const uint32_t streamId,
                                                const uint32_t zOrder,
                                                const float left,
                                                const float top,
                                                const float right,
                                                const float bottom)
 {
     CriticalSectionScoped cs(&_moduleCrit);
 
     if (!_ptrRenderer)
     {
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                      "%s: No renderer", __FUNCTION__);
         return NULL;
     }
 
     if (_streamRenderMap.find(streamId) != _streamRenderMap.end()) {
         // The stream already exists...
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                      "%s: stream already exists", __FUNCTION__);
         return NULL;
     }
 
-    VideoRenderCallback* ptrRenderCallback =
+    rtc::VideoSinkInterface<VideoFrame>* ptrRenderCallback =
             _ptrRenderer->AddIncomingRenderStream(streamId, zOrder, left, top,
                                                   right, bottom);
     if (ptrRenderCallback == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                      "%s: Can't create incoming stream in renderer",
                      __FUNCTION__);
         return NULL;
     }
 
     // Create platform independant code
     IncomingVideoStream* ptrIncomingStream =
-        new IncomingVideoStream(streamId, false);
+        new IncomingVideoStream(false);
     ptrIncomingStream->SetRenderCallback(ptrRenderCallback);
-    VideoRenderCallback* moduleCallback = ptrIncomingStream->ModuleCallback();
+    rtc::VideoSinkInterface<VideoFrame>* moduleCallback = ptrIncomingStream->ModuleCallback();

[perkj_webrtc, 2016/03/31 05:11:59]

line length

[nisse-webrtc, 2016/03/31 07:07:20]

Done.

 
     // Store the stream
     _streamRenderMap[streamId] = ptrIncomingStream;
 
     return moduleCallback;
 }
 
 int32_t ModuleVideoRenderImpl::DeleteIncomingRenderStream(
                                                                 const uint32_t streamId)
 {
@@ skipping 18 matching lines @@
 
     _ptrRenderer->DeleteIncomingRenderStream(streamId);
 
     _streamRenderMap.erase(item);
 
     return 0;
 }
 
 int32_t ModuleVideoRenderImpl::AddExternalRenderCallback(
     const uint32_t streamId,
-    VideoRenderCallback* renderObject) {
+    rtc::VideoSinkInterface<VideoFrame>* renderObject) {
     CriticalSectionScoped cs(&_moduleCrit);
 
     IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId);
 
     if (item == _streamRenderMap.end())
     {
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                      "%s: stream doesn't exist", __FUNCTION__);
         return -1;
     }
@@ skipping 37 matching lines @@
 
 bool ModuleVideoRenderImpl::HasIncomingRenderStream(
     const uint32_t streamId) const {
   CriticalSectionScoped cs(&_moduleCrit);
 
   return _streamRenderMap.find(streamId) != _streamRenderMap.end();
 }
 
 int32_t ModuleVideoRenderImpl::RegisterRawFrameCallback(
     const uint32_t streamId,
-    VideoRenderCallback* callbackObj) {
+    rtc::VideoSinkInterface<VideoFrame>* callbackObj) {
   return -1;
 }
 
 int32_t ModuleVideoRenderImpl::StartRender(const uint32_t streamId)
 {
     CriticalSectionScoped cs(&_moduleCrit);
 
     if (!_ptrRenderer)
     {
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
@@ skipping 286 matching lines @@
         WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                      "%s: stream doesn't exist", __FUNCTION__);
         return -1;
     }
     assert(item->second != NULL);
     item->second->SetTimeoutImage(videoFrame, timeout);
     return 0;
 }
 
 }  // namespace webrtc