VideoFrameBuffer: Make non-const data access explicit

webrtc/common_video/video_frame_buffer.cc

 /*
  *  Copyright (c) 2015 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 "webrtc/common_video/interface/video_frame_buffer.h"
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 
 // Aligning pointer to 64 bytes for improved performance, e.g. use SIMD.
 static const int kBufferAlignment = 64;
 
 namespace webrtc {
 namespace {
 
 // Used in rtc::Bind to keep a buffer alive until destructor is called.
 static void NoLongerUsedCallback(rtc::scoped_refptr<VideoFrameBuffer> dummy) {}
 
 }  // anonymous namespace
 
+uint8_t* VideoFrameBuffer::MutableData(PlaneType type) {
+  RTC_NOTREACHED();
+  return nullptr;
+}
+
 VideoFrameBuffer::~VideoFrameBuffer() {}
 
 I420Buffer::I420Buffer(int width, int height)
     : I420Buffer(width, height, width, (width + 1) / 2, (width + 1) / 2) {
 }
 
 I420Buffer::I420Buffer(int width,
                        int height,
                        int stride_y,
                        int stride_u,
@@ skipping 32 matching lines @@
       return data_.get() + stride_y_ * height_;
     case kVPlane:
       return data_.get() + stride_y_ * height_ +
              stride_u_ * ((height_ + 1) / 2);
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
 }
 
-uint8_t* I420Buffer::data(PlaneType type) {
+uint8_t* I420Buffer::MutableData(PlaneType type) {
   DCHECK(HasOneRef());
   return const_cast<uint8_t*>(
       static_cast<const VideoFrameBuffer*>(this)->data(type));
 }
 
 int I420Buffer::stride(PlaneType type) const {
   switch (type) {
     case kYPlane:
       return stride_y_;
     case kUPlane:
@@ skipping 30 matching lines @@
 
 int NativeHandleBuffer::height() const {
   return height_;
 }
 
 const uint8_t* NativeHandleBuffer::data(PlaneType type) const {
   RTC_NOTREACHED();  // Should not be called.
   return nullptr;
 }
 
-uint8_t* NativeHandleBuffer::data(PlaneType type) {
-  RTC_NOTREACHED();  // Should not be called.
-  return nullptr;
-}
-
 int NativeHandleBuffer::stride(PlaneType type) const {
   RTC_NOTREACHED();  // Should not be called.
   return 0;
 }
 
 void* NativeHandleBuffer::native_handle() const {
   return native_handle_;
 }
 
 WrappedI420Buffer::WrappedI420Buffer(int width,
@@ skipping 35 matching lines @@
     case kUPlane:
       return u_plane_;
     case kVPlane:
       return v_plane_;
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
 }
 
-uint8_t* WrappedI420Buffer::data(PlaneType type) {
-  RTC_NOTREACHED();
-  return nullptr;
-}
-
 int WrappedI420Buffer::stride(PlaneType type) const {
   switch (type) {
     case kYPlane:
       return y_stride_;
     case kUPlane:
       return u_stride_;
     case kVPlane:
       return v_stride_;
     default:
       RTC_NOTREACHED();
@@ skipping 20 matching lines @@
   if (buffer->width() == cropped_width && buffer->height() == cropped_height)
     return buffer;
 
   // Center crop to |cropped_width| x |cropped_height|.
   // Make sure offset is even so that u/v plane becomes aligned.
   const int uv_offset_x = (buffer->width() - cropped_width) / 4;
   const int uv_offset_y = (buffer->height() - cropped_height) / 4;
   const int offset_x = uv_offset_x * 2;
   const int offset_y = uv_offset_y * 2;
 
-  // Const cast to call the correct const-version of data().
-  const VideoFrameBuffer* const_buffer(buffer.get());
-  const uint8_t* y_plane = const_buffer->data(kYPlane) +
+  const uint8_t* y_plane = buffer->data(kYPlane) +
                            buffer->stride(kYPlane) * offset_y + offset_x;
-  const uint8_t* u_plane = const_buffer->data(kUPlane) +
+  const uint8_t* u_plane = buffer->data(kUPlane) +
                            buffer->stride(kUPlane) * uv_offset_y + uv_offset_x;
-  const uint8_t* v_plane = const_buffer->data(kVPlane) +
+  const uint8_t* v_plane = buffer->data(kVPlane) +
                            buffer->stride(kVPlane) * uv_offset_y + uv_offset_x;
   return new rtc::RefCountedObject<WrappedI420Buffer>(
       cropped_width, cropped_height,
       y_plane, buffer->stride(kYPlane),
       u_plane, buffer->stride(kUPlane),
       v_plane, buffer->stride(kVPlane),
       rtc::Bind(&NoLongerUsedCallback, buffer));
 }
 
 }  // namespace webrtc