Rename functions in video frame to comply with Style Guide

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 <climits>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 36 matching lines @@
       return "UNKNOWN";
     case VideoFrame::STORAGE_OPAQUE:
       return "OPAQUE";
     case VideoFrame::STORAGE_UNOWNED_MEMORY:
       return "UNOWNED_MEMORY";
     case VideoFrame::STORAGE_OWNED_MEMORY:
       return "OWNED_MEMORY";
     case VideoFrame::STORAGE_SHMEM:
       return "SHMEM";
 #if defined(OS_LINUX)
-    case VideoFrame::STORAGE_DMABUFS:
+    case VideoFrame::STORAGE_NATIVE:
       return "DMABUFS";
 #endif
     case VideoFrame::STORAGE_MOJO_SHARED_BUFFER:
       return "MOJO_SHARED_BUFFER";
   }
 
   NOTREACHED() << "Invalid StorageType provided: " << storage_type;
   return "INVALID";
 }
 
 // Returns true if |frame| is accesible mapped in the VideoFrame memory space.
 // static
 static bool IsStorageTypeMappable(VideoFrame::StorageType storage_type) {
   return
 #if defined(OS_LINUX)
       // This is not strictly needed but makes explicit that, at VideoFrame
       // level, DmaBufs are not mappable from userspace.
-      storage_type != VideoFrame::STORAGE_DMABUFS &&
+      storage_type != VideoFrame::STORAGE_NATIVE &&
 #endif
       (storage_type == VideoFrame::STORAGE_UNOWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_OWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_SHMEM ||
        storage_type == VideoFrame::STORAGE_MOJO_SHARED_BUFFER);
 }
 
 // Checks if |source_format| can be wrapped into a |target_format| frame.
 static bool AreValidPixelFormatsForWrap(VideoPixelFormat source_format,
                                         VideoPixelFormat target_format) {
@@ skipping 240 matching lines @@
 
 #if defined(OS_LINUX)
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalDmabufs(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     const std::vector<int>& dmabuf_fds,
     base::TimeDelta timestamp) {
-  const StorageType storage = STORAGE_DMABUFS;
+  const StorageType storage = STORAGE_NATIVE;
   if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
     LOG(DFATAL) << __func__ << " Invalid config."
                 << ConfigToString(format, storage, coded_size, visible_rect,
                                   natural_size);
     return nullptr;
   }
 
   gpu::MailboxHolder mailbox_holders[kMaxPlanes];
   scoped_refptr<VideoFrame> frame =
       new VideoFrame(format, storage, coded_size, visible_rect, natural_size,
@@ skipping 84 matching lines @@
   // Copy all metadata to the wrapped frame.
   wrapping_frame->metadata()->MergeMetadataFrom(frame->metadata());
 
   for (size_t i = 0; i < NumPlanes(format); ++i) {
     wrapping_frame->strides_[i] = frame->stride(i);
     wrapping_frame->data_[i] = frame->data(i);
   }
 
 #if defined(OS_LINUX)
   // If there are any |dmabuf_fds_| plugged in, we should duplicate them.
-  if (frame->storage_type() == STORAGE_DMABUFS) {
+  if (frame->storage_type() == STORAGE_NATIVE) {
     std::vector<int> original_fds;
     for (size_t i = 0; i < kMaxPlanes; ++i)
-      original_fds.push_back(frame->dmabuf_fd(i));
+      original_fds.push_back(frame->DmabufFd(i));
     if (!wrapping_frame->DuplicateFileDescriptors(original_fds)) {
       LOG(DFATAL) << __func__ << " Couldn't duplicate fds.";
       return nullptr;
     }
   }
 #endif
 
   if (frame->storage_type() == STORAGE_SHMEM)
     wrapping_frame->AddSharedMemoryHandle(frame->shared_memory_handle_);
 
@@ skipping 261 matching lines @@
   return shared_memory_handle_;
 }
 
 size_t VideoFrame::shared_memory_offset() const {
   DCHECK_EQ(storage_type_, STORAGE_SHMEM);
   DCHECK(shared_memory_handle_ != base::SharedMemory::NULLHandle());
   return shared_memory_offset_;
 }
 
 #if defined(OS_LINUX)
-int VideoFrame::dmabuf_fd(size_t plane) const {
-  DCHECK_EQ(storage_type_, STORAGE_DMABUFS);
+int VideoFrame::DmabufFd(size_t plane) const {
+  DCHECK_EQ(storage_type_, STORAGE_NATIVE);
   DCHECK(IsValidPlane(plane, format_));
   return dmabuf_fds_[plane].get();
 }
 
 bool VideoFrame::DuplicateFileDescriptors(const std::vector<int>& in_fds) {
   // TODO(mcasas): Support offsets for e.g. multiplanar inside a single |in_fd|.
 
-  storage_type_ = STORAGE_DMABUFS;
+  storage_type_ = STORAGE_NATIVE;
   // TODO(posciak): This is not exactly correct, it's possible for one
   // buffer to contain more than one plane.
   if (in_fds.size() != NumPlanes(format_)) {
     LOG(FATAL) << "Not enough dmabuf fds provided, got: " <<  in_fds.size()
                << ", expected: " << NumPlanes(format_);
     return false;
   }
 
   // Make sure that all fds are closed if any dup() fails,
   base::ScopedFD temp_dmabuf_fds[kMaxPlanes];
@@ skipping 10 matching lines @@
   return true;
 }
 #endif
 
 void VideoFrame::AddSharedMemoryHandle(base::SharedMemoryHandle handle) {
   storage_type_ = STORAGE_SHMEM;
   shared_memory_handle_ = handle;
 }
 
 #if defined(OS_MACOSX)
-CVPixelBufferRef VideoFrame::cv_pixel_buffer() const {
+CVPixelBufferRef VideoFrame::CvPixelBuffer() const {
   return cv_pixel_buffer_.get();
 }
 #endif
 
 void VideoFrame::SetReleaseMailboxCB(
     const ReleaseMailboxCB& release_mailbox_cb) {
   DCHECK(!release_mailbox_cb.is_null());
   DCHECK(mailbox_holders_release_cb_.is_null());
   mailbox_holders_release_cb_ = release_mailbox_cb;
 }
@@ skipping 429 matching lines @@
   if (zero_initialize_memory)
     memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media