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

content/renderer/media/webrtc/webrtc_video_capturer_adapter.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/webrtc_video_capturer_adapter.h"
 
 #include "base/bind.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/renderer/media/webrtc/webrtc_video_frame_adapter.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_util.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/scale.h"
 #include "third_party/skia/include/core/SkSurface.h"
-#include "third_party/webrtc/common_video/include/video_frame_buffer.h"
 #include "third_party/webrtc/common_video/rotation.h"
-#include "third_party/webrtc/media/engine/webrtcvideoframe.h"
 
 namespace content {
 
 namespace {
 
 // Empty method used for keeping a reference to the original media::VideoFrame.
 // The reference to |frame| is kept in the closure that calls this method.
 void ReleaseOriginalFrame(const scoped_refptr<media::VideoFrame>& frame) {
 }
 
@@ skipping 158 matching lines @@
                   rtc::TimeMicros(),
                   &adapted_width, &adapted_height,
                   &crop_width, &crop_height, &crop_x, &crop_y,
                   &translated_camera_time_us)) {
     return;
   }
 
   // Return |frame| directly if it is texture backed, because there is no
   // cropping support for texture yet. See http://crbug/503653.
   if (frame->HasTextures()) {
-    OnFrame(cricket::WebRtcVideoFrame(
+    OnFrame(webrtc::VideoFrame(
                 new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(
                     frame, base::Bind(&TextureFrameCopier::CopyTextureFrame,
                                       texture_copier_)),
                 webrtc::kVideoRotation_0, translated_camera_time_us),
             orig_width, orig_height);
     return;
   }
 
   // Translate crop rectangle from natural size to visible size.
   gfx::Rect cropped_visible_rect(
       frame->visible_rect().x() +
           crop_x * frame->visible_rect().width() / orig_width,
       frame->visible_rect().y() +
           crop_y * frame->visible_rect().height() / orig_height,
       crop_width * frame->visible_rect().width() / orig_width,
       crop_height * frame->visible_rect().height() / orig_height);
 
   const gfx::Size adapted_size(adapted_width, adapted_height);
   scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::WrapVideoFrame(frame, frame->format(),
                                         cropped_visible_rect, adapted_size);
   if (!video_frame)
     return;
 
   video_frame->AddDestructionObserver(base::Bind(&ReleaseOriginalFrame, frame));
 
   // If no scaling is needed, return a wrapped version of |frame| directly.
   if (video_frame->natural_size() == video_frame->visible_rect().size()) {
-    OnFrame(cricket::WebRtcVideoFrame(
+    OnFrame(webrtc::VideoFrame(
                 new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(
                     video_frame,
                     WebRtcVideoFrameAdapter::CopyTextureFrameCallback()),
                 webrtc::kVideoRotation_0, translated_camera_time_us),
             orig_width, orig_height);
     return;
   }
 
   // We need to scale the frame before we hand it over to webrtc.
   scoped_refptr<media::VideoFrame> scaled_frame =
       scaled_frame_pool_.CreateFrame(media::PIXEL_FORMAT_I420, adapted_size,
                                      gfx::Rect(adapted_size), adapted_size,
                                      frame->timestamp());
   libyuv::I420Scale(video_frame->visible_data(media::VideoFrame::kYPlane),
                     video_frame->stride(media::VideoFrame::kYPlane),
                     video_frame->visible_data(media::VideoFrame::kUPlane),
                     video_frame->stride(media::VideoFrame::kUPlane),
                     video_frame->visible_data(media::VideoFrame::kVPlane),
                     video_frame->stride(media::VideoFrame::kVPlane),
                     video_frame->visible_rect().width(),
                     video_frame->visible_rect().height(),
                     scaled_frame->data(media::VideoFrame::kYPlane),
                     scaled_frame->stride(media::VideoFrame::kYPlane),
                     scaled_frame->data(media::VideoFrame::kUPlane),
                     scaled_frame->stride(media::VideoFrame::kUPlane),
                     scaled_frame->data(media::VideoFrame::kVPlane),
                     scaled_frame->stride(media::VideoFrame::kVPlane),
                     adapted_width, adapted_height, libyuv::kFilterBilinear);
 
-  OnFrame(cricket::WebRtcVideoFrame(
+  OnFrame(webrtc::VideoFrame(
               new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(
                   scaled_frame,
                   WebRtcVideoFrameAdapter::CopyTextureFrameCallback()),
               webrtc::kVideoRotation_0, translated_camera_time_us),
           orig_width, orig_height);
 }
 
 cricket::CaptureState WebRtcVideoCapturerAdapter::Start(
     const cricket::VideoFormat& capture_format) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 42 matching lines @@
   // just use what is provided.
   // Use the desired format as the best format.
   best_format->width = desired.width;
   best_format->height = desired.height;
   best_format->fourcc = cricket::FOURCC_I420;
   best_format->interval = desired.interval;
   return true;
 }
 
 }  // namespace content