Fix DCHECKs in V4l2VideoDevice.

media/base/video_frame.cc

 // Copyright (c) 2012 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 "media/base/video_frame.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 671 matching lines @@
       // thread (imply a memory barrier).
       base::AutoLock locker(release_sync_point_lock_);
       release_sync_point = release_sync_point_;
     }
     base::ResetAndReturn(&mailbox_holder_release_cb_).Run(release_sync_point);
   }
   if (!no_longer_needed_cb_.is_null())
     base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
-bool VideoFrame::IsValidPlane(size_t plane) const {
-  return (plane < NumPlanes(format_));
+// static
+bool VideoFrame::IsValidPlane(size_t plane, VideoFrame::Format format) {
+  return (plane < NumPlanes(format));
 }
 
 int VideoFrame::stride(size_t plane) const {
-  DCHECK(IsValidPlane(plane));
+  DCHECK(IsValidPlane(plane, format_));
   return strides_[plane];
 }
 
-int VideoFrame::row_bytes(size_t plane) const {
-  DCHECK(IsValidPlane(plane));
-  int width = coded_size_.width();
-  switch (format_) {
+// static
+int VideoFrame::RowBytes(size_t plane, VideoFrame::Format format, int width) {
+  DCHECK(IsValidPlane(plane, format));
+  switch (format) {
     case VideoFrame::YV24:
       switch (plane) {
         case kYPlane:
         case kUPlane:
         case kVPlane:
           return width;
         default:
           break;
       }
       break;
@@ skipping 32 matching lines @@
           break;
       }
       break;
     case VideoFrame::UNKNOWN:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::NATIVE_TEXTURE:
       break;
   }
-  NOTREACHED() << "Unsupported video frame format/plane: "
-               << format_ << "/" << plane;
+  NOTREACHED() << "Unsupported video frame format/plane: " << format << "/"
+               << plane;
   return 0;
 }
 
+int VideoFrame::row_bytes(size_t plane) const {
+  return RowBytes(plane, format_, coded_size_.width());
+}
+
 int VideoFrame::rows(size_t plane) const {
-  DCHECK(IsValidPlane(plane));
+  DCHECK(IsValidPlane(plane, format_));
   int height = coded_size_.height();
   switch (format_) {
     case VideoFrame::YV24:
     case VideoFrame::YV16:
       switch (plane) {
         case kYPlane:
         case kUPlane:
         case kVPlane:
           return height;
         default:
@@ skipping 41 matching lines @@
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::NATIVE_TEXTURE:
       break;
   }
   NOTREACHED() << "Unsupported video frame format/plane: "
                << format_ << "/" << plane;
   return 0;
 }
 
 uint8* VideoFrame::data(size_t plane) const {
-  DCHECK(IsValidPlane(plane));
+  DCHECK(IsValidPlane(plane, format_));
   return data_[plane];
 }
 
 const gpu::MailboxHolder* VideoFrame::mailbox_holder() const {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
   return mailbox_holder_.get();
 }
 
 base::SharedMemoryHandle VideoFrame::shared_memory_handle() const {
   return shared_memory_handle_;
@@ skipping 11 matching lines @@
 }
 
 #if defined(OS_POSIX)
 int VideoFrame::dmabuf_fd(size_t plane) const {
   return dmabuf_fds_[plane].get();
 }
 #endif
 
 void VideoFrame::HashFrameForTesting(base::MD5Context* context) {
   for (int plane = 0; plane < kMaxPlanes; ++plane) {
-    if (!IsValidPlane(plane))
+    if (!IsValidPlane(plane, format_))
       break;
     for (int row = 0; row < rows(plane); ++row) {
       base::MD5Update(context, base::StringPiece(
           reinterpret_cast<char*>(data(plane) + stride(plane) * row),
           row_bytes(plane)));
     }
   }
 }
 
 }  // namespace media