gfx_param_traits.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/gfx/ipc/gfx_param_traits.h"

#include <stddef.h>
#include <stdint.h>

#include <string>

#include "base/format_macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "ui/gfx/ipc/geometry/gfx_param_traits.h"
#include "ui/gfx/range/range.h"

#if BUILDFLAG(IS_APPLE)
#include "ipc/mach_port_mac.h"
#endif

namespace IPC {

void ParamTraits<gfx::Range>::Write(base::Pickle* m, const gfx::Range& r) { … }

bool ParamTraits<gfx::Range>::Read(const base::Pickle* m,
                                   base::PickleIterator* iter,
                                   gfx::Range* r) { … }

void ParamTraits<gfx::Range>::Log(const gfx::Range& r, std::string* l) { … }

#if BUILDFLAG(IS_APPLE)
void ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Write(
    base::Pickle* m,
    const param_type p) {
  MachPortMac mach_port_mac(p.get());
  ParamTraits<MachPortMac>::Write(m, mach_port_mac);
}

bool ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Read(
    const base::Pickle* m,
    base::PickleIterator* iter,
    param_type* r) {
  MachPortMac mach_port_mac;
  if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
    return false;
  r->reset(mach_port_mac.get_mach_port());
  return true;
}

void ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Log(
    const param_type& p,
    std::string* l) {
  l->append("IOSurface Mach send right: ");
  LogParam(p.get(), l);
}

void ParamTraits<gfx::ScopedIOSurface>::Write(base::Pickle* m,
                                              const param_type p) {
  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
      IOSurfaceCreateMachPort(p.get()));
  MachPortMac mach_port_mac(io_surface_mach_port.get());
  ParamTraits<MachPortMac>::Write(m, mach_port_mac);
}

bool ParamTraits<gfx::ScopedIOSurface>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             param_type* r) {
  MachPortMac mach_port_mac;
  if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
    return false;
  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
      mach_port_mac.get_mach_port());
  if (io_surface_mach_port)
    r->reset(IOSurfaceLookupFromMachPort(io_surface_mach_port.get()));
  else
    r->reset();
  return true;
}

void ParamTraits<gfx::ScopedIOSurface>::Log(const param_type& p,
                                            std::string* l) {
  l->append("IOSurface(");
  if (p) {
    uint32_t io_surface_id = IOSurfaceGetID(p.get());
    LogParam(io_surface_id, l);
  }
  l->append(")");
}
#endif  // BUILDFLAG(IS_APPLE)

void ParamTraits<gfx::SelectionBound>::Write(base::Pickle* m,
                                             const param_type& p) { … }

bool ParamTraits<gfx::SelectionBound>::Read(const base::Pickle* m,
                                            base::PickleIterator* iter,
                                            param_type* r) { … }

void ParamTraits<gfx::SelectionBound>::Log(const param_type& p,
                                           std::string* l) { … }

}  // namespace IPC

// Generate param traits write methods.
#include "ipc/param_traits_write_macros.h"
namespace IPC {
#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
#include "ui/gfx/ipc/gfx_param_traits_macros.h"
}  // namespace IPC

// Generate param traits read methods.
#include "ipc/param_traits_read_macros.h"
namespace IPC {
#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
#include "ui/gfx/ipc/gfx_param_traits_macros.h"
}  // namespace IPC

// Generate param traits log methods.
#include "ipc/param_traits_log_macros.h"
namespace IPC {
#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
#include "ui/gfx/ipc/gfx_param_traits_macros.h"
}  // namespace IPC
chromium/ui/gfx/ipc/gfx_param_traits.cc
