Renamed Decoder -> VideoDecoder.

remoting/codec/video_decoder_row_based.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_row_based.h"
 
 #include "base/logging.h"
 #include "remoting/base/decompressor.h"
 #include "remoting/base/decompressor_zlib.h"
 #include "remoting/base/decompressor_verbatim.h"
 #include "remoting/base/util.h"
 
 namespace remoting {
 
 namespace {
 // Both input and output data are assumed to be RGBA32.
 const int kBytesPerPixel = 4;
 }
 
-DecoderRowBased* DecoderRowBased::CreateZlibDecoder() {
-  return new DecoderRowBased(new DecompressorZlib(),
-                             VideoPacketFormat::ENCODING_ZLIB);
+VideoDecoderRowBased* VideoDecoderRowBased::CreateZlibDecoder() {
+  return new VideoDecoderRowBased(new DecompressorZlib(),
+                                  VideoPacketFormat::ENCODING_ZLIB);
 }
 
-DecoderRowBased* DecoderRowBased::CreateVerbatimDecoder() {
-  return new DecoderRowBased(new DecompressorVerbatim(),
-                             VideoPacketFormat::ENCODING_VERBATIM);
+VideoDecoderRowBased* VideoDecoderRowBased::CreateVerbatimDecoder() {
+  return new VideoDecoderRowBased(new DecompressorVerbatim(),
+                                  VideoPacketFormat::ENCODING_VERBATIM);
 }
 
-DecoderRowBased::DecoderRowBased(Decompressor* decompressor,
-                                 VideoPacketFormat::Encoding encoding)
+VideoDecoderRowBased::VideoDecoderRowBased(Decompressor* decompressor,
+                                           VideoPacketFormat::Encoding encoding)
     : state_(kUninitialized),
       clip_(SkIRect::MakeEmpty()),
       decompressor_(decompressor),
       encoding_(encoding),
       row_pos_(0),
       row_y_(0),
       screen_size_(SkISize::Make(0, 0)) {
 }
 
-DecoderRowBased::~DecoderRowBased() {
+VideoDecoderRowBased::~VideoDecoderRowBased() {
 }
 
-bool DecoderRowBased::IsReadyForData() {
+bool VideoDecoderRowBased::IsReadyForData() {
   switch (state_) {
     case kUninitialized:
     case kError:
       return false;
     case kReady:
     case kProcessing:
     case kPartitionDone:
     case kDone:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
-void DecoderRowBased::Initialize(const SkISize& screen_size) {
+void VideoDecoderRowBased::Initialize(const SkISize& screen_size) {
   decompressor_->Reset();
   updated_region_.setEmpty();
   screen_buffer_.reset(NULL);
 
   screen_size_ = screen_size;
   // Allocate the screen buffer, if necessary.
   if (!screen_size_.isEmpty()) {
     screen_buffer_.reset(new uint8[
         screen_size_.width() * screen_size_.height() * kBytesPerPixel]);
   }
 
   state_ = kReady;
 }
 
-Decoder::DecodeResult DecoderRowBased::DecodePacket(const VideoPacket* packet) {
+VideoDecoder::DecodeResult VideoDecoderRowBased::DecodePacket(
+    const VideoPacket* packet) {
   UpdateStateForPacket(packet);
 
   if (state_ == kError) {
     return DECODE_ERROR;
   }
 
   const uint8* in = reinterpret_cast<const uint8*>(packet->data().data());
   const int in_size = packet->data().size();
   const int row_size = clip_.width() * kBytesPerPixel;
 
@@ skipping 38 matching lines @@
     decompressor_->Reset();
   }
 
   if (state_ == kDone) {
     return DECODE_DONE;
   } else {
     return DECODE_IN_PROGRESS;
   }
 }
 
-void DecoderRowBased::UpdateStateForPacket(const VideoPacket* packet) {
+void VideoDecoderRowBased::UpdateStateForPacket(const VideoPacket* packet) {
   if (state_ == kError) {
     return;
   }
 
   if (packet->flags() & VideoPacket::FIRST_PACKET) {
     if (state_ != kReady && state_ != kDone && state_ != kPartitionDone) {
       state_ = kError;
       LOG(WARNING) << "Received unexpected FIRST_PACKET.";
       return;
     }
@@ skipping 32 matching lines @@
       state_ = kError;
       LOG(WARNING) << "Received unexpected LAST_PARTITION.";
       return;
     }
     state_ = kDone;
   }
 
   return;
 }
 
-VideoPacketFormat::Encoding DecoderRowBased::Encoding() {
+VideoPacketFormat::Encoding VideoDecoderRowBased::Encoding() {
   return encoding_;
 }
 
-void DecoderRowBased::Invalidate(const SkISize& view_size,
-                                 const SkRegion& region) {
+void VideoDecoderRowBased::Invalidate(const SkISize& view_size,
+                                      const SkRegion& region) {
   updated_region_.op(region, SkRegion::kUnion_Op);
 }
 
-void DecoderRowBased::RenderFrame(const SkISize& view_size,
-                                  const SkIRect& clip_area,
-                                  uint8* image_buffer,
-                                  int image_stride,
-                                  SkRegion* output_region) {
+void VideoDecoderRowBased::RenderFrame(const SkISize& view_size,
+                                       const SkIRect& clip_area,
+                                       uint8* image_buffer,
+                                       int image_stride,
+                                       SkRegion* output_region) {
   output_region->setEmpty();
 
   // TODO(alexeypa): scaling is not implemented.
   SkIRect clip_rect = SkIRect::MakeSize(screen_size_);
   if (!clip_rect.intersect(clip_area))
     return;
 
   int screen_stride = screen_size_.width() * kBytesPerPixel;
 
   for (SkRegion::Iterator i(updated_region_); !i.done(); i.next()) {
     SkIRect rect(i.rect());
     if (!rect.intersect(clip_rect))
       continue;
 
     CopyRGB32Rect(screen_buffer_.get(), screen_stride,
                   clip_rect,
                   image_buffer, image_stride,
                   clip_area,
                   rect);
     output_region->op(rect, SkRegion::kUnion_Op);
   }
 
   updated_region_.setEmpty();
 }
 
 }  // namespace remoting