Replace all use of cricket::VideoFrame and cricket::WebRtcVideoFrame with webrtc::VideoFrame.

content/renderer/media/webrtc/media_stream_remote_video_source.cc

 // Copyright 2014 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/renderer/media/webrtc/media_stream_remote_video_source.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/webrtc/track_observer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
-#include "third_party/webrtc/media/base/videoframe.h"
 #include "third_party/webrtc/media/base/videosinkinterface.h"
 
 namespace content {
 
 namespace {
 
 media::VideoRotation WebRTCToMediaVideoRotation(
     webrtc::VideoRotation rotation) {
   switch (rotation) {
     case webrtc::kVideoRotation_0:
       return media::VIDEO_ROTATION_0;
     case webrtc::kVideoRotation_90:
       return media::VIDEO_ROTATION_90;
     case webrtc::kVideoRotation_180:
       return media::VIDEO_ROTATION_180;
     case webrtc::kVideoRotation_270:
       return media::VIDEO_ROTATION_270;
   }
   return media::VIDEO_ROTATION_0;
 }
 
 }  // anonymous namespace
 
 // Internal class used for receiving frames from the webrtc track on a
 // libjingle thread and forward it to the IO-thread.
 class MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate
     : public base::RefCountedThreadSafe<RemoteVideoSourceDelegate>,
-      public rtc::VideoSinkInterface<cricket::VideoFrame> {
+      public rtc::VideoSinkInterface<webrtc::VideoFrame> {
  public:
   RemoteVideoSourceDelegate(
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       const VideoCaptureDeliverFrameCB& new_frame_callback);
 
  protected:
   friend class base::RefCountedThreadSafe<RemoteVideoSourceDelegate>;
   ~RemoteVideoSourceDelegate() override;
 
   // Implements rtc::VideoSinkInterface used for receiving video frames
   // from the PeerConnection video track. May be called on a libjingle internal
   // thread.
-  void OnFrame(const cricket::VideoFrame& frame) override;
+  void OnFrame(const webrtc::VideoFrame& frame) override;
 
   void DoRenderFrameOnIOThread(
       const scoped_refptr<media::VideoFrame>& video_frame);
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // |frame_callback_| is accessed on the IO thread.
   VideoCaptureDeliverFrameCB frame_callback_;
 
@@ skipping 18 matching lines @@
 
 MediaStreamRemoteVideoSource::
 RemoteVideoSourceDelegate::~RemoteVideoSourceDelegate() {
 }
 
 namespace {
 void DoNothing(const scoped_refptr<rtc::RefCountInterface>& ref) {}
 }  // anonymous
 
 void MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::OnFrame(
-    const cricket::VideoFrame& incoming_frame) {
+    const webrtc::VideoFrame& incoming_frame) {
   const base::TimeDelta incoming_timestamp = base::TimeDelta::FromMicroseconds(
       incoming_frame.timestamp_us());
   const base::TimeTicks render_time =
       base::TimeTicks() + incoming_timestamp + time_diff_;
 
   TRACE_EVENT1("webrtc", "RemoteVideoSourceDelegate::RenderFrame",
                "Ideal Render Instant", render_time.ToInternalValue());
 
   CHECK_NE(media::kNoTimestamp, incoming_timestamp);
   if (start_timestamp_ == media::kNoTimestamp)
@@ skipping 109 matching lines @@
   if (!observer_)
     return;
   DCHECK(state() != MediaStreamVideoSource::ENDED);
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       static_cast<webrtc::VideoTrackInterface*>(observer_->track().get()));
   video_track->RemoveSink(delegate_.get());
   // This removes the references to the webrtc video track.
   observer_.reset();
 }
 
-rtc::VideoSinkInterface<cricket::VideoFrame>*
+rtc::VideoSinkInterface<webrtc::VideoFrame>*
 MediaStreamRemoteVideoSource::SinkInterfaceForTest() {
   return delegate_.get();
 }
 
 void MediaStreamRemoteVideoSource::OnChanged(
     webrtc::MediaStreamTrackInterface::TrackState state) {
   DCHECK(CalledOnValidThread());
   switch (state) {
     case webrtc::MediaStreamTrackInterface::kLive:
       SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
       break;
     case webrtc::MediaStreamTrackInterface::kEnded:
       SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace content