Renamed Decoder -> VideoDecoder.

remoting/codec/video_decoder_vp8.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 "remoting/codec/video_decoder_vp8.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "media/base/media.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/util.h"
 
 extern "C" {
 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "third_party/libvpx/libvpx.h"
 }
 
 namespace remoting {
 
-DecoderVp8::DecoderVp8()
+VideoDecoderVp8::VideoDecoderVp8()
     : state_(kUninitialized),
       codec_(NULL),
       last_image_(NULL),
       screen_size_(SkISize::Make(0, 0)) {
 }
 
-DecoderVp8::~DecoderVp8() {
+VideoDecoderVp8::~VideoDecoderVp8() {
   if (codec_) {
     vpx_codec_err_t ret = vpx_codec_destroy(codec_);
     CHECK(ret == VPX_CODEC_OK) << "Failed to destroy codec";
   }
   delete codec_;
 }
 
-void DecoderVp8::Initialize(const SkISize& screen_size) {
+void VideoDecoderVp8::Initialize(const SkISize& screen_size) {
   DCHECK(!screen_size.isEmpty());
 
   screen_size_ = screen_size;
   state_ = kReady;
 }
 
-Decoder::DecodeResult DecoderVp8::DecodePacket(const VideoPacket* packet) {
+VideoDecoder::DecodeResult VideoDecoderVp8::DecodePacket(
+    const VideoPacket* packet) {
   DCHECK_EQ(kReady, state_);
 
   // Initialize the codec as needed.
   if (!codec_) {
     codec_ = new vpx_codec_ctx_t();
 
     // TODO(hclam): Scale the number of threads with number of cores of the
     // machine.
     vpx_codec_dec_cfg config;
     config.w = 0;
@@ skipping 38 matching lines @@
                                      remoting_rect.y(),
                                      remoting_rect.width(),
                                      remoting_rect.height());
     region.op(rect, SkRegion::kUnion_Op);
   }
 
   updated_region_.op(region, SkRegion::kUnion_Op);
   return DECODE_DONE;
 }
 
-bool DecoderVp8::IsReadyForData() {
+bool VideoDecoderVp8::IsReadyForData() {
   return state_ == kReady;
 }
 
-VideoPacketFormat::Encoding DecoderVp8::Encoding() {
+VideoPacketFormat::Encoding VideoDecoderVp8::Encoding() {
   return VideoPacketFormat::ENCODING_VP8;
 }
 
-void DecoderVp8::Invalidate(const SkISize& view_size,
-                            const SkRegion& region) {
+void VideoDecoderVp8::Invalidate(const SkISize& view_size,
+                                 const SkRegion& region) {
   DCHECK_EQ(kReady, state_);
   DCHECK(!view_size.isEmpty());
 
   for (SkRegion::Iterator i(region); !i.done(); i.next()) {
     SkIRect rect = i.rect();
     rect = ScaleRect(rect, view_size, screen_size_);
     updated_region_.op(rect, SkRegion::kUnion_Op);
   }
 }
 
-void DecoderVp8::RenderFrame(const SkISize& view_size,
-                             const SkIRect& clip_area,
-                             uint8* image_buffer,
-                             int image_stride,
-                             SkRegion* output_region) {
+void VideoDecoderVp8::RenderFrame(const SkISize& view_size,
+                                  const SkIRect& clip_area,
+                                  uint8* image_buffer,
+                                  int image_stride,
+                                  SkRegion* output_region) {
   DCHECK_EQ(kReady, state_);
   DCHECK(!view_size.isEmpty());
 
   // Early-return and do nothing if we haven't yet decoded any frames.
   if (!last_image_)
     return;
 
   SkIRect source_clip = SkIRect::MakeWH(last_image_->d_w, last_image_->d_h);
 
   // ScaleYUVToRGB32WithRect does not currently support up-scaling.  We won't
@@ skipping 65 matching lines @@
                                   rect);
 
     output_region->op(rect, SkRegion::kUnion_Op);
   }
 
   updated_region_.op(ScaleRect(clip_area, view_size, screen_size_),
                      SkRegion::kDifference_Op);
 }
 
 }  // namespace remoting