Move IPC traits for SkBitmap, gfx_geometry into ui/gfx/ipc

ui/gfx/ipc/gfx_param_traits.cc

 // Copyright (c) 2012 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 "content/public/common/common_param_traits.h"
+#include "ui/gfx/ipc/gfx_param_traits.h"
 
 #include <string>
 
-#include "content/public/common/content_constants.h"
-#include "content/public/common/page_state.h"
-#include "content/public/common/referrer.h"
-#include "content/public/common/url_utils.h"
-#include "net/base/host_port_pair.h"
-#include "net/base/ip_endpoint.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
 
 namespace {
 
 struct SkBitmap_Data {
   // The configuration for the bitmap (bits per pixel, etc).
   SkBitmap::Config fConfig;

[reed1, 2014/06/20 13:30:55]

I think you can replace the first 3 fields with SkImageInfo

 
   // The width of the bitmap in pixels.
   uint32 fWidth;
 
   // The height of the bitmap in pixels.
   uint32 fHeight;
 
   void InitSkBitmapDataForTransfer(const SkBitmap& bitmap) {
     fConfig = bitmap.config();
     fWidth = bitmap.width();
     fHeight = bitmap.height();
   }
 
   // Returns whether |bitmap| successfully initialized.
   bool InitSkBitmapFromData(SkBitmap* bitmap, const char* pixels,
                             size_t total_pixels) const {
     if (total_pixels) {

[reed1, 2014/06/20 13:30:55]

This method could then become

    bitmap->installPixels(fInfo, pixels, rowbytes);

If you don't have an explicit rowbytes, you can use info.minRowBytes().

       bitmap->setConfig(fConfig, fWidth, fHeight, 0);
       if (!bitmap->allocPixels())
         return false;
       if (total_pixels != bitmap->getSize())
         return false;
       memcpy(bitmap->getPixels(), pixels, total_pixels);
     }
     return true;
   }
 };
 
 }  // namespace
 
 namespace IPC {
 
-void ParamTraits<GURL>::Write(Message* m, const GURL& p) {
-  DCHECK(p.possibly_invalid_spec().length() <= content::GetMaxURLChars());
-
-  // Beware of print-parse inconsistency which would change an invalid
-  // URL into a valid one. Ideally, the message would contain this flag
-  // so that the read side could make the check, but performing it here
-  // avoids changing the on-the-wire representation of such a fundamental
-  // type as GURL. See https://crbug.com/166486 for additional work in
-  // this area.
-  if (!p.is_valid()) {
-    m->WriteString(std::string());
-    return;
-  }
-
-  m->WriteString(p.possibly_invalid_spec());
-  // TODO(brettw) bug 684583: Add encoding for query params.
-}
-
-bool ParamTraits<GURL>::Read(const Message* m, PickleIterator* iter, GURL* p) {
-  std::string s;
-  if (!m->ReadString(iter, &s) || s.length() > content::GetMaxURLChars()) {
-    *p = GURL();
-    return false;
-  }
-  *p = GURL(s);
-  if (!s.empty() && !p->is_valid()) {
-    *p = GURL();
-    return false;
-  }
-  return true;
-}
-
-void ParamTraits<GURL>::Log(const GURL& p, std::string* l) {
-  l->append(p.spec());
-}
-
-void ParamTraits<url::Origin>::Write(Message* m,
-                                          const url::Origin& p) {
-  m->WriteString(p.string());
-}
-
-bool ParamTraits<url::Origin>::Read(const Message* m,
-                                    PickleIterator* iter,
-                                    url::Origin* p) {
-  std::string s;
-  if (!m->ReadString(iter, &s)) {
-    *p = url::Origin();
-    return false;
-  }
-  *p = url::Origin(s);
-  return true;
-}
-
-void ParamTraits<url::Origin>::Log(const url::Origin& p, std::string* l) {
-  l->append(p.string());
-}
-
-void ParamTraits<net::HostPortPair>::Write(Message* m, const param_type& p) {
-  WriteParam(m, p.host());
-  WriteParam(m, p.port());
-}
-
-bool ParamTraits<net::HostPortPair>::Read(const Message* m,
-                                          PickleIterator* iter,
-                                          param_type* r) {
-  std::string host;
-  uint16 port;
-  if (!ReadParam(m, iter, &host) || !ReadParam(m, iter, &port))
-    return false;
-
-  r->set_host(host);
-  r->set_port(port);
-  return true;
-}
-
-void ParamTraits<net::HostPortPair>::Log(const param_type& p, std::string* l) {
-  l->append(p.ToString());
-}
-
-void ParamTraits<net::IPEndPoint>::Write(Message* m, const param_type& p) {
-  WriteParam(m, p.address());
-  WriteParam(m, p.port());
-}
-
-bool ParamTraits<net::IPEndPoint>::Read(const Message* m, PickleIterator* iter,
-                                        param_type* p) {
-  net::IPAddressNumber address;
-  int port;
-  if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port))
-    return false;
-  if (address.size() &&
-      address.size() != net::kIPv4AddressSize &&
-      address.size() != net::kIPv6AddressSize) {
-    return false;
-  }
-  *p = net::IPEndPoint(address, port);
-  return true;
-}
-
-void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) {
-  LogParam("IPEndPoint:" + p.ToString(), l);
-}
-
-void ParamTraits<content::PageState>::Write(
-    Message* m, const param_type& p) {
-  WriteParam(m, p.ToEncodedData());
-}
-
-bool ParamTraits<content::PageState>::Read(
-    const Message* m, PickleIterator* iter, param_type* r) {
-  std::string data;
-  if (!ReadParam(m, iter, &data))
-    return false;
-  *r = content::PageState::CreateFromEncodedData(data);
-  return true;
-}
-
-void ParamTraits<content::PageState>::Log(
-    const param_type& p, std::string* l) {
-  l->append("(");
-  LogParam(p.ToEncodedData(), l);
-  l->append(")");
-}
-
 void ParamTraits<gfx::Point>::Write(Message* m, const gfx::Point& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
 bool ParamTraits<gfx::Point>::Read(const Message* m, PickleIterator* iter,
                                    gfx::Point* r) {
   int x, y;
   if (!m->ReadInt(iter, &x) ||
       !m->ReadInt(iter, &y))
@@ skipping 195 matching lines @@
   const SkBitmap_Data* bmp_data =
       reinterpret_cast<const SkBitmap_Data*>(fixed_data);
   return bmp_data->InitSkBitmapFromData(r, variable_data, variable_data_size);
 }
 
 void ParamTraits<SkBitmap>::Log(const SkBitmap& p, std::string* l) {
   l->append("<SkBitmap>");
 }
 
 }  // namespace IPC
-
-// Generate param traits write methods.
-#include "ipc/param_traits_write_macros.h"
-namespace IPC {
-#undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_
-#include "content/public/common/common_param_traits_macros.h"
-}  // namespace IPC
-
-// Generate param traits read methods.
-#include "ipc/param_traits_read_macros.h"
-namespace IPC {
-#undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_
-#include "content/public/common/common_param_traits_macros.h"
-}  // namespace IPC
-
-// Generate param traits log methods.
-#include "ipc/param_traits_log_macros.h"
-namespace IPC {
-#undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_
-#include "content/public/common/common_param_traits_macros.h"
-}  // namespace IPC