Cleanup: Correctly spell success(ful).

media/filters/vpx_video_decoder.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/filters/vpx_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 100 matching lines @@
   // |min_size|   Minimum size needed by libvpx to decompress the next frame.
   // |fb|         Pointer to the frame buffer to update.
   // Returns 0 on success. Returns < 0 on failure.
   static int32 GetVP9FrameBuffer(void* user_priv, size_t min_size,
                                  vpx_codec_frame_buffer* fb);
 
   // Callback that will be called by libvpx when the frame buffer is no longer
   // being used by libvpx. Parameters:
   // |user_priv|  Private data passed to libvpx (pointer to memory pool).
   // |fb|         Pointer to the frame buffer that's being released.
-  static int32 ReleaseVP9FrameBuffer(void *user_priv,
-                                     vpx_codec_frame_buffer *fb);
+  static int32 ReleaseVP9FrameBuffer(void* user_priv,
+                                     vpx_codec_frame_buffer* fb);
 
   // Generates a "no_longer_needed" closure that holds a reference to this pool.
   base::Closure CreateFrameCallback(void* fb_priv_data);
 
   // base::MemoryDumpProvider.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
   int NumberOfFrameBuffersInUseByDecoder() const;
   int NumberOfFrameBuffersInUseByDecoderAndVideoFrame() const;
@@ skipping 76 matching lines @@
   fb->size = fb_to_use->data.size();
   ++fb_to_use->ref_cnt;
   ++memory_pool->in_use_by_decoder_;
 
   // Set the frame buffer's private data to point at the external frame buffer.
   fb->priv = static_cast<void*>(fb_to_use);
   return 0;
 }
 
 int32 VpxVideoDecoder::MemoryPool::ReleaseVP9FrameBuffer(
-    void *user_priv, vpx_codec_frame_buffer *fb) {
+    void* user_priv,
+    vpx_codec_frame_buffer* fb) {
   DCHECK(user_priv);
   DCHECK(fb);
   VP9FrameBuffer* frame_buffer = static_cast<VP9FrameBuffer*>(fb->priv);
   --frame_buffer->ref_cnt;
 
   VpxVideoDecoder::MemoryPool* memory_pool =
       static_cast<VpxVideoDecoder::MemoryPool*>(user_priv);
   --memory_pool->in_use_by_decoder_;
   if (frame_buffer->ref_cnt)
     --memory_pool->in_use_by_decoder_and_video_frame_;
@@ skipping 114 matching lines @@
     bound_decode_cb.Run(kOk);
     return;
   }
 
   scoped_refptr<VideoFrame> video_frame;
   if (!VpxDecode(buffer, &video_frame)) {
     state_ = kError;
     bound_decode_cb.Run(kDecodeError);
     return;
   }
-  // We might get a successfull VpxDecode but not a frame if only a partial
+  // We might get a successful VpxDecode but not a frame if only a partial
   // decode happened.
   if (video_frame.get())
     output_cb_.Run(video_frame);
 
   // VideoDecoderShim expects |decode_cb| call after |output_cb_|.
   bound_decode_cb.Run(kOk);
 }
 
 void VpxVideoDecoder::Reset(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 236 matching lines @@
       (*video_frame)->visible_data(VideoFrame::kYPlane),
       (*video_frame)->stride(VideoFrame::kYPlane),
       (*video_frame)->visible_data(VideoFrame::kUPlane),
       (*video_frame)->stride(VideoFrame::kUPlane),
       (*video_frame)->visible_data(VideoFrame::kVPlane),
       (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 }
 
 }  // namespace media