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

remoting/base/codec_test.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 <deque>
 #include <stdlib.h>
 
 #include "gfx/rect.h"
 #include "media/base/video_frame.h"
 #include "remoting/base/codec_test.h"
@@ skipping 67 matching lines @@
 
   ~EncoderMessageTester() {
     EXPECT_EQ(begin_rect_, end_rect_);
     EXPECT_EQ(kWaitingForBeginRect, state_);
     if (strict_){
       EXPECT_EQ(begin_rect_, added_rects_);
     }
   }
 
   // Test that we received the correct message.
-  void ReceivedMessage(HostMessage* message) {
+  void ReceivedMessage(ChromotingHostMessage* message) {
     EXPECT_TRUE(message->has_update_stream_packet());
 
     if (state_ == kWaitingForBeginRect) {
       EXPECT_TRUE(message->update_stream_packet().has_begin_rect());
       state_ = kWaitingForRectData;
       ++begin_rect_;
 
       if (strict_) {
         gfx::Rect rect = rects_.front();
         rects_.pop_front();
@@ skipping 56 matching lines @@
       : strict_(false),
         decoder_(decoder),
         decode_done_(false) {
     media::VideoFrame::CreateFrame(media::VideoFrame::RGB32,
                                    kWidth, kHeight,
                                    base::TimeDelta(),
                                    base::TimeDelta(), &frame_);
     EXPECT_TRUE(frame_.get());
   }
 
-  void ReceivedMessage(HostMessage* message) {
+  void ReceivedMessage(ChromotingHostMessage* message) {
     if (message->has_update_stream_packet()) {
       decoder_->PartialDecode(message);
       return;
     }
 
     if (message->has_begin_update_stream()) {
       decoder_->BeginDecode(
           frame_, &update_rects_,
           NewRunnableMethod(this, &DecoderTester::OnPartialDecodeDone),
           NewRunnableMethod(this, &DecoderTester::OnDecodeDone));
@@ skipping 82 matching lines @@
       : message_tester_(message_tester),
         state_tester_(state_tester),
         decoder_tester_(NULL),
         data_available_(0) {
   }
 
   ~EncoderTester() {
     EXPECT_GT(data_available_, 0);
   }
 
-  void DataAvailable(HostMessage* message,
+  void DataAvailable(ChromotingHostMessage* message,
                      Encoder::EncodingState state) {
     ++data_available_;
     message_tester_->ReceivedMessage(message);
     state_tester_->ReceivedState(state);
 
     // Send the message to the DecoderTester.
     if (decoder_tester_) {
       if (state & Encoder::EncodingStarting) {
-        HostMessage* begin_update = new HostMessage();
+        ChromotingHostMessage* begin_update = new ChromotingHostMessage();
         begin_update->mutable_begin_update_stream();
         decoder_tester_->ReceivedMessage(begin_update);
       }
 
       if (state & Encoder::EncodingInProgress) {
         decoder_tester_->ReceivedMessage(message);
       }
 
       if (state & Encoder::EncodingEnded) {
-        HostMessage* end_update = new HostMessage();
+        ChromotingHostMessage* end_update = new ChromotingHostMessage();
         end_update->mutable_end_update_stream();
         decoder_tester_->ReceivedMessage(end_update);
       }
     } else {
       delete message;
     }
   }
 
   void AddRects(const gfx::Rect* rects, int count) {
     message_tester_->AddRects(rects, count);
@@ skipping 123 matching lines @@
   TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
                     kTestRects + 2, 1);
   TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
                     kTestRects + 3, 2);
   delete [] memory;
 }
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::DecoderTester);