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

remoting/host/client_connection.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/host/client_connection.h"
 
 #include "google/protobuf/message.h"
 #include "media/base/data_buffer.h"
 #include "remoting/base/protocol_decoder.h"
 #include "remoting/base/protocol_util.h"
@@ skipping 20 matching lines @@
 }
 
 ClientConnection::~ClientConnection() {
   // TODO(hclam): When we shut down the viewer we may have to close the
   // jingle channel.
 }
 
 // static
 scoped_refptr<media::DataBuffer>
     ClientConnection::CreateWireFormatDataBuffer(
-        const HostMessage* msg) {
+        const ChromotingHostMessage* msg) {
   // TODO(hclam): Instead of serializing |msg| create an DataBuffer
   // object that wraps around it.
-  scoped_ptr<const HostMessage> message_deleter(msg);
+  scoped_ptr<const ChromotingHostMessage> message_deleter(msg);
   return SerializeAndFrameMessage(*msg);
 }
 
 void ClientConnection::SendInitClientMessage(int width, int height) {
   DCHECK_EQ(loop_, MessageLoop::current());
   DCHECK(!update_stream_size_);
 
   // If we are disconnected then return.
   if (!channel_)
     return;
 
-  HostMessage msg;
+  ChromotingHostMessage msg;
   msg.mutable_init_client()->set_width(width);
   msg.mutable_init_client()->set_height(height);
   DCHECK(msg.IsInitialized());
   channel_->Write(SerializeAndFrameMessage(msg));
 }
 
 void ClientConnection::SendBeginUpdateStreamMessage() {
   DCHECK_EQ(loop_, MessageLoop::current());
 
   // If we are disconnected then return.
   if (!channel_)
     return;
 
-  HostMessage msg;
+  ChromotingHostMessage msg;
   msg.mutable_begin_update_stream();
   DCHECK(msg.IsInitialized());
 
   scoped_refptr<DataBuffer> data = SerializeAndFrameMessage(msg);
   DCHECK(!update_stream_size_);
   update_stream_size_ += data->GetDataSize();
   channel_->Write(data);
 }
 
 void ClientConnection::SendUpdateStreamPacketMessage(
     scoped_refptr<DataBuffer> data) {
   DCHECK_EQ(loop_, MessageLoop::current());
 
   // If we are disconnected then return.
   if (!channel_)
     return;
 
   update_stream_size_ += data->GetDataSize();
   channel_->Write(data);
 }
 
 void ClientConnection::SendEndUpdateStreamMessage() {
   DCHECK_EQ(loop_, MessageLoop::current());
 
   // If we are disconnected then return.
   if (!channel_)
     return;
 
-  HostMessage msg;
+  ChromotingHostMessage msg;
   msg.mutable_end_update_stream();
   DCHECK(msg.IsInitialized());
 
   scoped_refptr<DataBuffer> data = SerializeAndFrameMessage(msg);
   update_stream_size_ += data->GetDataSize();
   channel_->Write(data);
 
   // Here's some logic to help finding the average update stream size.
   size_in_queue_ += update_stream_size_;
   size_queue_.push_back(update_stream_size_);
@@ skipping 70 matching lines @@
   DCHECK(decoder_.get());
   ClientMessageList list;
   decoder_->ParseClientMessages(data, &list);
 
   // Then submit the messages to the handler.
   DCHECK(handler_);
   handler_->HandleMessages(this, &list);
 }
 
 }  // namespace remoting