IPC::Message -> base::Pickle

remoting/host/chromoting_param_traits.cc

 // Copyright 2013 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/chromoting_param_traits.h"
 
 #include <stdint.h>
 
 #include "base/strings/stringprintf.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace IPC {
 
 // static
-void ParamTraits<webrtc::DesktopVector>::Write(Message* m,
+void ParamTraits<webrtc::DesktopVector>::Write(base::Pickle* m,
                                                const webrtc::DesktopVector& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
 // static
-bool ParamTraits<webrtc::DesktopVector>::Read(const Message* m,
+bool ParamTraits<webrtc::DesktopVector>::Read(const base::Pickle* m,
                                               base::PickleIterator* iter,
                                               webrtc::DesktopVector* r) {
   int x, y;
   if (!iter->ReadInt(&x) || !iter->ReadInt(&y))
     return false;
   *r = webrtc::DesktopVector(x, y);
   return true;
 }
 
 // static
 void ParamTraits<webrtc::DesktopVector>::Log(const webrtc::DesktopVector& p,
                                              std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopVector(%d, %d)",
                                p.x(), p.y()));
 }
 
 // static
-void ParamTraits<webrtc::DesktopSize>::Write(Message* m,
+void ParamTraits<webrtc::DesktopSize>::Write(base::Pickle* m,
                                              const webrtc::DesktopSize& p) {
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
 // static
-bool ParamTraits<webrtc::DesktopSize>::Read(const Message* m,
+bool ParamTraits<webrtc::DesktopSize>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             webrtc::DesktopSize* r) {
   int width, height;
   if (!iter->ReadInt(&width) || !iter->ReadInt(&height))
     return false;
   *r = webrtc::DesktopSize(width, height);
   return true;
 }
 
 // static
 void ParamTraits<webrtc::DesktopSize>::Log(const webrtc::DesktopSize& p,
                                            std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopSize(%d, %d)",
                                p.width(), p.height()));
 }
 
 // static
-void ParamTraits<webrtc::DesktopRect>::Write(Message* m,
+void ParamTraits<webrtc::DesktopRect>::Write(base::Pickle* m,
                                              const webrtc::DesktopRect& p) {
   m->WriteInt(p.left());
   m->WriteInt(p.top());
   m->WriteInt(p.right());
   m->WriteInt(p.bottom());
 }
 
 // static
-bool ParamTraits<webrtc::DesktopRect>::Read(const Message* m,
+bool ParamTraits<webrtc::DesktopRect>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             webrtc::DesktopRect* r) {
   int left, right, top, bottom;
   if (!iter->ReadInt(&left) || !iter->ReadInt(&top) ||
       !iter->ReadInt(&right) || !iter->ReadInt(&bottom)) {
     return false;
   }
   *r = webrtc::DesktopRect::MakeLTRB(left, top, right, bottom);
   return true;
 }
 
 // static
 void ParamTraits<webrtc::DesktopRect>::Log(const webrtc::DesktopRect& p,
                                            std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopRect(%d, %d, %d, %d)",
                                p.left(), p.top(), p.right(), p.bottom()));
 }
 
 // static
-void ParamTraits<webrtc::MouseCursor>::Write(
-    Message* m,
-    const webrtc::MouseCursor& p) {
+void ParamTraits<webrtc::MouseCursor>::Write(base::Pickle* m,
+                                             const webrtc::MouseCursor& p) {
   ParamTraits<webrtc::DesktopSize>::Write(m, p.image()->size());
 
   // Data is serialized in such a way that size is exactly width * height *
   // |kBytesPerPixel|.
   std::string data;
   uint8_t* current_row = p.image()->data();
   for (int y = 0; y < p.image()->size().height(); ++y) {
     data.append(current_row,
                 current_row + p.image()->size().width() *
                     webrtc::DesktopFrame::kBytesPerPixel);
     current_row += p.image()->stride();
   }
   m->WriteData(reinterpret_cast<const char*>(p.image()->data()), data.size());
 
   ParamTraits<webrtc::DesktopVector>::Write(m, p.hotspot());
 }
 
 // static
-bool ParamTraits<webrtc::MouseCursor>::Read(const Message* m,
+bool ParamTraits<webrtc::MouseCursor>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             webrtc::MouseCursor* r) {
   webrtc::DesktopSize size;
   if (!ParamTraits<webrtc::DesktopSize>::Read(m, iter, &size) ||
       size.width() <= 0 || size.width() > (SHRT_MAX / 2) ||
       size.height() <= 0 || size.height() > (SHRT_MAX / 2)) {
     return false;
   }
 
   const int expected_length =
@@ skipping 22 matching lines @@
     std::string* l) {
   l->append(base::StringPrintf(
       "webrtc::DesktopRect{image(%d, %d), hotspot(%d, %d)}",
       p.image()->size().width(), p.image()->size().height(),
       p.hotspot().x(), p.hotspot().y()));
 }
 
 
 // static
 void ParamTraits<remoting::ScreenResolution>::Write(
-    Message* m,
+    base::Pickle* m,
     const remoting::ScreenResolution& p) {
   ParamTraits<webrtc::DesktopSize>::Write(m, p.dimensions());
   ParamTraits<webrtc::DesktopVector>::Write(m, p.dpi());
 }
 
 // static
 bool ParamTraits<remoting::ScreenResolution>::Read(
-    const Message* m,
+    const base::Pickle* m,
     base::PickleIterator* iter,
     remoting::ScreenResolution* r) {
   webrtc::DesktopSize size;
   webrtc::DesktopVector dpi;
   if (!ParamTraits<webrtc::DesktopSize>::Read(m, iter, &size) ||
       !ParamTraits<webrtc::DesktopVector>::Read(m, iter, &dpi)) {
     return false;
   }
   if (size.width() < 0 || size.height() < 0 ||
       dpi.x() < 0 || dpi.y() < 0) {
     return false;
   }
   *r = remoting::ScreenResolution(size, dpi);
   return true;
 }
 
 // static
 void ParamTraits<remoting::ScreenResolution>::Log(
     const remoting::ScreenResolution& p,
     std::string* l) {
   l->append(base::StringPrintf("webrtc::ScreenResolution(%d, %d, %d, %d)",
                                p.dimensions().width(), p.dimensions().height(),
                                p.dpi().x(), p.dpi().y()));
 }
 
 }  // namespace IPC