Make it easier to create new IPC channel types (i.e. renderer/plugin). Inste...

chrome/common/ipc_message_utils.cc

 // Copyright (c) 2006-2008 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 "chrome/common/ipc_message_utils.h"
 
 #include "base/gfx/rect.h"
 #include "googleurl/src/gurl.h"
 #include "SkBitmap.h"
 #include "webkit/glue/dom_operations.h"
 
-namespace IPC {
-
 namespace {
 
 struct SkBitmap_Data {
   // The configuration for the bitmap (bits per pixel, etc).
   SkBitmap::Config fConfig;
 
   // The width of the bitmap in pixels.
   uint32 fWidth;
 
   // The height of the bitmap in pixels.
@@ skipping 15 matching lines @@
       bitmap->setConfig(fConfig, fWidth, fHeight, fRowBytes);
       bitmap->allocPixels();
       memcpy(bitmap->getPixels(), pixels, total_pixels);
     }
   }
 };
 
 }  // namespace
 
 
-void ParamTraits<SkBitmap>::Write(Message* m, const SkBitmap& p) {
+void ParamTraits<SkBitmap>::Write(IPC::Message* m, const SkBitmap& p) {
   size_t fixed_size = sizeof(SkBitmap_Data);
   SkBitmap_Data bmp_data;
   bmp_data.InitSkBitmapDataForTransfer(p);
   m->WriteData(reinterpret_cast<const char*>(&bmp_data),
                static_cast<int>(fixed_size));
   size_t pixel_size = p.getSize();
   SkAutoLockPixels p_lock(p);
   m->WriteData(reinterpret_cast<const char*>(p.getPixels()),
                static_cast<int>(pixel_size));
 }
 
-bool ParamTraits<SkBitmap>::Read(const Message* m, void** iter, SkBitmap* r) {
+bool ParamTraits<SkBitmap>::Read(const IPC::Message* m, void** iter, SkBitmap* r) {
   const char* fixed_data;
   int fixed_data_size = 0;
   if (!m->ReadData(iter, &fixed_data, &fixed_data_size) ||
      (fixed_data_size <= 0)) {
     NOTREACHED();
     return false;
   }
   if (fixed_data_size != sizeof(SkBitmap_Data))
     return false;  // Message is malformed.
 
   const char* variable_data;
   int variable_data_size = 0;
   if (!m->ReadData(iter, &variable_data, &variable_data_size) ||
      (variable_data_size < 0)) {
     NOTREACHED();
     return false;
   }
   const SkBitmap_Data* bmp_data =
       reinterpret_cast<const SkBitmap_Data*>(fixed_data);
   bmp_data->InitSkBitmapFromData(r, variable_data, variable_data_size);
   return true;
 }
 
 void ParamTraits<SkBitmap>::Log(const SkBitmap& p, std::wstring* l) {
   l->append(StringPrintf(L"<SkBitmap>"));
 }
 
 
-void ParamTraits<GURL>::Write(Message* m, const GURL& p) {
+void ParamTraits<GURL>::Write(IPC::Message* m, const GURL& p) {
   m->WriteString(p.possibly_invalid_spec());
   // TODO(brettw) bug 684583: Add encoding for query params.
 }
 
-bool ParamTraits<GURL>::Read(const Message* m, void** iter, GURL* p) {
+bool ParamTraits<GURL>::Read(const IPC::Message* m, void** iter, GURL* p) {
   std::string s;
   if (!m->ReadString(iter, &s)) {
     *p = GURL();
     return false;
   }
   *p = GURL(s);
   return true;
 }
 
 void ParamTraits<GURL>::Log(const GURL& p, std::wstring* l) {
   l->append(UTF8ToWide(p.spec()));
 }
 
 
-void ParamTraits<gfx::Point>::Write(Message* m, const gfx::Point& p) {
+void ParamTraits<gfx::Point>::Write(IPC::Message* m, const gfx::Point& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
-bool ParamTraits<gfx::Point>::Read(const Message* m, void** iter,
+bool ParamTraits<gfx::Point>::Read(const IPC::Message* m, void** iter,
                                    gfx::Point* r) {
   int x, y;
   if (!m->ReadInt(iter, &x) ||
       !m->ReadInt(iter, &y))
     return false;
   r->set_x(x);
   r->set_y(y);
   return true;
 }
 
 void ParamTraits<gfx::Point>::Log(const gfx::Point& p, std::wstring* l) {
   l->append(StringPrintf(L"(%d, %d)", p.x(), p.y()));
 }
 
 
-void ParamTraits<gfx::Rect>::Write(Message* m, const gfx::Rect& p) {
+void ParamTraits<gfx::Rect>::Write(IPC::Message* m, const gfx::Rect& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
-bool ParamTraits<gfx::Rect>::Read(const Message* m, void** iter, gfx::Rect* r) {
+bool ParamTraits<gfx::Rect>::Read(const IPC::Message* m, void** iter, gfx::Rect* r) {
   int x, y, w, h;
   if (!m->ReadInt(iter, &x) ||
       !m->ReadInt(iter, &y) ||
       !m->ReadInt(iter, &w) ||
       !m->ReadInt(iter, &h))
     return false;
   r->set_x(x);
   r->set_y(y);
   r->set_width(w);
   r->set_height(h);
   return true;
 }
 
 void ParamTraits<gfx::Rect>::Log(const gfx::Rect& p, std::wstring* l) {
   l->append(StringPrintf(L"(%d, %d, %d, %d)", p.x(), p.y(),
                          p.width(), p.height()));
 }
 
 
-void ParamTraits<gfx::Size>::Write(Message* m, const gfx::Size& p) {
+void ParamTraits<gfx::Size>::Write(IPC::Message* m, const gfx::Size& p) {
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
-bool ParamTraits<gfx::Size>::Read(const Message* m, void** iter, gfx::Size* r) {
+bool ParamTraits<gfx::Size>::Read(const IPC::Message* m, void** iter, gfx::Size* r) {
   int w, h;
   if (!m->ReadInt(iter, &w) ||
       !m->ReadInt(iter, &h))
     return false;
   r->set_width(w);
   r->set_height(h);
   return true;
 }
 
 void ParamTraits<gfx::Size>::Log(const gfx::Size& p, std::wstring* l) {
   l->append(StringPrintf(L"(%d, %d)", p.width(), p.height()));
 }
 
 void ParamTraits<webkit_glue::WebApplicationInfo>::Write(
-    Message* m, const webkit_glue::WebApplicationInfo& p) {
+    IPC::Message* m, const webkit_glue::WebApplicationInfo& p) {
   WriteParam(m, p.title);
   WriteParam(m, p.description);
   WriteParam(m, p.app_url);
   WriteParam(m, p.icons.size());
   for (size_t i = 0; i < p.icons.size(); ++i) {
     WriteParam(m, p.icons[i].url);
     WriteParam(m, p.icons[i].width);
     WriteParam(m, p.icons[i].height);
   }
 }
 
 bool ParamTraits<webkit_glue::WebApplicationInfo>::Read(
-    const Message* m, void** iter, webkit_glue::WebApplicationInfo* r) {
+    const IPC::Message* m, void** iter, webkit_glue::WebApplicationInfo* r) {
   size_t icon_count;
   bool result =
     ReadParam(m, iter, &r->title) &&
     ReadParam(m, iter, &r->description) &&
     ReadParam(m, iter, &r->app_url) &&
     ReadParam(m, iter, &icon_count);
   if (!result)
     return false;
   for (size_t i = 0; i < icon_count && result; ++i) {
     param_type::IconInfo icon_info;
     result =
         ReadParam(m, iter, &icon_info.url) &&
         ReadParam(m, iter, &icon_info.width) &&
         ReadParam(m, iter, &icon_info.height);
     r->icons.push_back(icon_info);
   }
   return result;
 }
 
 void ParamTraits<webkit_glue::WebApplicationInfo>::Log(
     const webkit_glue::WebApplicationInfo& p, std::wstring* l) {
   l->append(L"<WebApplicationInfo>");
 }
-
-}  // namespace IPC
-