Rename (Host|Client)Message to Chromoting(Host|Client)Message.

remoting/base/decoder_zlib.cc

 // Copyright (c) 2010 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/base/decoder_zlib.h"
 
 #include "remoting/base/decompressor_zlib.h"
 #include "remoting/base/protocol_util.h"
 
 namespace remoting {
@@ skipping 35 matching lines @@
   updated_rects_ = updated_rects;
   frame_ = frame;
 
   // Create the decompressor.
   decompressor_.reset(new DecompressorZlib());
 
   started_ = true;
   return true;
 }
 
-bool DecoderZlib::PartialDecode(HostMessage* message) {
-  scoped_ptr<HostMessage> msg_deleter(message);
+bool DecoderZlib::PartialDecode(ChromotingHostMessage* message) {
+  scoped_ptr<ChromotingHostMessage> msg_deleter(message);
   DCHECK(message->has_update_stream_packet());
   DCHECK(started_);
 
   bool ret = true;
   if (message->update_stream_packet().has_begin_rect())
     ret = HandleBeginRect(message);
   if (ret && message->update_stream_packet().has_rect_data())
     ret = HandleRectData(message);
   if (ret && message->update_stream_packet().has_end_rect())
     ret = HandleEndRect(message);
   return ret;
 }
 
 void DecoderZlib::EndDecode() {
   DCHECK_EQ(kWaitingForBeginRect, state_);
   DCHECK(started_);
 
   decode_done_->Run();
 
   partial_decode_done_.reset();
   decode_done_.reset();
   updated_rects_ = NULL;
   frame_ = NULL;
   decompressor_.reset();
   started_ = false;
 }
 
-bool DecoderZlib::HandleBeginRect(HostMessage* message) {
+bool DecoderZlib::HandleBeginRect(ChromotingHostMessage* message) {
   DCHECK_EQ(kWaitingForBeginRect, state_);
   state_ = kWaitingForRectData;
 
   rect_width_ = message->update_stream_packet().begin_rect().width();
   rect_height_ = message->update_stream_packet().begin_rect().height();
   rect_x_ = message->update_stream_packet().begin_rect().x();
   rect_y_ = message->update_stream_packet().begin_rect().y();
 
   PixelFormat pixel_format =
       message->update_stream_packet().begin_rect().pixel_format();
 
   if (static_cast<PixelFormat>(frame_->format()) != pixel_format) {
     NOTREACHED() << "Pixel format of message doesn't match the video frame. "
                     "Expected vs received = "
                  << frame_->format() << " vs " << pixel_format
                  << " Color space conversion required.";
     return false;
   }
 
   bytes_per_pixel_ = GetBytesPerPixel(pixel_format);
   row_pos_ = 0;
   row_y_ = 0;
   return true;
 }
 
-bool DecoderZlib::HandleRectData(HostMessage* message) {
+bool DecoderZlib::HandleRectData(ChromotingHostMessage* message) {
   DCHECK_EQ(kWaitingForRectData, state_);
   DCHECK_EQ(0,
             message->update_stream_packet().rect_data().sequence_number());
 
   const uint8* in =
       (const uint8*)message->update_stream_packet().rect_data().data().data();
   const int in_size =
       message->update_stream_packet().rect_data().data().size();
   const int row_size = rect_width_ * bytes_per_pixel_;
   int stride = frame_->stride(media::VideoFrame::kRGBPlane);
@@ skipping 24 matching lines @@
     // If this row is completely filled then move onto the next row.
     if (row_pos_ == row_size) {
       ++row_y_;
       row_pos_ = 0;
       out += stride;
     }
   }
   return true;
 }
 
-bool DecoderZlib::HandleEndRect(HostMessage* message) {
+bool DecoderZlib::HandleEndRect(ChromotingHostMessage* message) {
   DCHECK_EQ(kWaitingForRectData, state_);
   state_ = kWaitingForBeginRect;
 
   updated_rects_->clear();
   updated_rects_->push_back(gfx::Rect(rect_x_, rect_y_,
                                       rect_width_, rect_height_));
   partial_decode_done_->Run();
   return true;
 }
 
 }  // namespace remoting