path: root/printing/pdf_ps_metafile_cairo.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 "printing/pdf_ps_metafile_cairo.h"

#include <stdio.h>

#include <cairo.h>
#include <cairo-pdf.h>
#include <cairo-ps.h>

#include "base/eintr_wrapper.h"
#include "base/file_descriptor_posix.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "printing/units.h"
#include "skia/ext/vector_platform_device_linux.h"

namespace {

const cairo_user_data_key_t kPdfMetafileKey = {0};

// Tests if |surface| is valid.
bool IsSurfaceValid(cairo_surface_t* surface) {
  return cairo_surface_status(surface) == CAIRO_STATUS_SUCCESS;
}

// Tests if |context| is valid.
bool IsContextValid(cairo_t* context) {
  return cairo_status(context) == CAIRO_STATUS_SUCCESS;
}

// Destroys and resets |surface|.
void CleanUpSurface(cairo_surface_t** surface) {
  if (*surface) {
    cairo_surface_destroy(*surface);
    *surface = NULL;
  }
}

// Destroys and resets |context|.
void CleanUpContext(cairo_t** context) {
  if (*context) {
    cairo_destroy(*context);
    *context = NULL;
  }
}

// Callback function for Cairo to write PDF/PS stream.
// |dst_buffer| is actually a pointer of type `std::string*`.
cairo_status_t WriteCairoStream(void* dst_buffer,
                                const unsigned char* src_data,
                                unsigned int src_data_length) {
  DCHECK(dst_buffer);
  DCHECK(src_data);
  DCHECK_GT(src_data_length, 0u);

  std::string* buffer = reinterpret_cast<std::string*>(dst_buffer);
  buffer->append(reinterpret_cast<const char*>(src_data), src_data_length);

  return CAIRO_STATUS_SUCCESS;
}

void DestroyContextData(void* data) {
  // Nothing to be done here.
}

}  // namespace

namespace printing {

PdfPsMetafile::PdfPsMetafile()
    : format_(PDF),
      surface_(NULL), context_(NULL) {
}

PdfPsMetafile::PdfPsMetafile(const FileFormat& format)
    : format_(format),
      surface_(NULL), context_(NULL) {
}

PdfPsMetafile::~PdfPsMetafile() {
  // Releases all resources if we forgot to do so.
  CleanUpAll();
}

bool PdfPsMetafile::Init() {
  // We need to check at least these two members to ensure Init() has not been
  // called before.
  DCHECK(!context_);
  DCHECK(data_.empty());

  // Creates an 1 by 1 Cairo surface for entire PDF/PS file.
  // The size for each page will be overwritten later in StartPage().
  switch (format_) {
    case PDF:
      surface_ = cairo_pdf_surface_create_for_stream(WriteCairoStream,
                                                     &data_, 1, 1);
      break;

    case PS:
      surface_ = cairo_ps_surface_create_for_stream(WriteCairoStream,
                                                    &data_, 1, 1);
      break;

    default:
      NOTREACHED();
      return false;
  }

  // Cairo always returns a valid pointer.
  // Hence, we have to check if it points to a "nil" object.
  if (!IsSurfaceValid(surface_)) {
    DLOG(ERROR) << "Cannot create Cairo surface for PdfPsMetafile!";
    CleanUpSurface(&surface_);
    return false;
  }

  // Creates a context.
  context_ = cairo_create(surface_);
  if (!IsContextValid(context_)) {
    DLOG(ERROR) << "Cannot create Cairo context for PdfPsMetafile!";
    CleanUpContext(&context_);
    CleanUpSurface(&surface_);
    return false;
  }

  cairo_set_user_data(context_, &kPdfMetafileKey, this, DestroyContextData);

  return true;
}

bool PdfPsMetafile::Init(const void* src_buffer, uint32 src_buffer_size) {
  // We need to check at least these two members to ensure Init() has not been
  // called before
  DCHECK(!context_);
  DCHECK(data_.empty());

  if (src_buffer == NULL || src_buffer_size == 0)
    return false;

  data_ = std::string(reinterpret_cast<const char*>(src_buffer),
                      src_buffer_size);

  return true;
}

bool PdfPsMetafile::SetRawData(const void* src_buffer,
                               uint32 src_buffer_size) {
  if (!context_) {
    // If Init has not already been called, just call Init()
    return Init(src_buffer, src_buffer_size);
  }
  // If a context has already been created, remember this data in
  // raw_override_data_
  if (src_buffer == NULL || src_buffer_size == 0)
    return false;

  raw_override_data_ = std::string(reinterpret_cast<const char*>(src_buffer),
                                   src_buffer_size);

  return true;
}

cairo_t* PdfPsMetafile::StartPage(double width_in_points,
                                  double height_in_points,
                                  double margin_top_in_points,
                                  double margin_right_in_points,
                                  double margin_bottom_in_points,
                                  double margin_left_in_points) {
  DCHECK(IsSurfaceValid(surface_));
  DCHECK(IsContextValid(context_));
  // Passing this check implies page_surface_ is NULL, and current_page_ is
  // empty.
  DCHECK_GT(width_in_points, 0.);
  DCHECK_GT(height_in_points, 0.);

  // We build in extra room for the margins. The Cairo PDF backend will scale
  // the output to fit a page.
  double width =
      width_in_points + margin_left_in_points + margin_right_in_points;
  double height =
      height_in_points + margin_top_in_points + margin_bottom_in_points;

  // Don't let WebKit draw over the margins.
  cairo_surface_set_device_offset(surface_,
                                  margin_left_in_points,
                                  margin_top_in_points);

  switch (format_) {
    case PDF:
      cairo_pdf_surface_set_size(surface_, width, height);
      break;

    case PS:
      cairo_ps_surface_set_size(surface_, width, height);
      break;

    default:
      NOTREACHED();
      CleanUpAll();
      return NULL;
  }

  return context_;
}

bool PdfPsMetafile::FinishPage() {
  DCHECK(IsSurfaceValid(surface_));
  DCHECK(IsContextValid(context_));

  // Flushes all rendering for current page.
  cairo_surface_flush(surface_);
  cairo_show_page(context_);
  return true;
}

void PdfPsMetafile::Close() {
  DCHECK(IsSurfaceValid(surface_));
  DCHECK(IsContextValid(context_));

  cairo_surface_finish(surface_);

  // If we have raw PDF/PS data set use that instead of what was drawn.
  if (!raw_override_data_.empty()) {
    data_ = raw_override_data_;
    raw_override_data_.clear();
  }
  DCHECK(!data_.empty());  // Make sure we did get something.

  CleanUpContext(&context_);
  CleanUpSurface(&surface_);
}

uint32 PdfPsMetafile::GetDataSize() const {
  // We need to check at least these two members to ensure that either Init()
  // has been called to initialize |data_|, or metafile has been closed.
  DCHECK(!context_);
  DCHECK(!data_.empty());

  return data_.size();
}

bool PdfPsMetafile::GetData(void* dst_buffer, uint32 dst_buffer_size) const {
  DCHECK(dst_buffer);
  DCHECK_GT(dst_buffer_size, 0u);
  memcpy(dst_buffer, data_.data(), dst_buffer_size);

  return true;
}

bool PdfPsMetafile::SaveTo(const base::FileDescriptor& fd) const {
  // We need to check at least these two members to ensure that either Init()
  // has been called to initialize |data_|, or metafile has been closed.
  DCHECK(!context_);
  DCHECK(!data_.empty());

  if (fd.fd < 0) {
    DLOG(ERROR) << "Invalid file descriptor!";
    return false;
  }

  bool success = true;
  if (file_util::WriteFileDescriptor(fd.fd, data_.data(),
                                     GetDataSize()) < 0) {
    DLOG(ERROR) << "Failed to save file with fd " << fd.fd;
    success = false;
  }

  if (fd.auto_close) {
    if (HANDLE_EINTR(close(fd.fd)) < 0) {
      DPLOG(WARNING) << "close";
      success = false;
    }
  }

  return success;
}

PdfPsMetafile* PdfPsMetafile::FromCairoContext(cairo_t* context) {
  return reinterpret_cast<PdfPsMetafile*>(
      cairo_get_user_data(context, &kPdfMetafileKey));
}

void PdfPsMetafile::CleanUpAll() {
  CleanUpContext(&context_);
  CleanUpSurface(&surface_);
  data_.clear();
  skia::VectorPlatformDevice::ClearFontCache();
}

const double PdfPsMetafile::kTopMarginInInch = 0.25;
const double PdfPsMetafile::kBottomMarginInInch = 0.56;
const double PdfPsMetafile::kLeftMarginInInch = 0.25;
const double PdfPsMetafile::kRightMarginInInch = 0.25;

}  // namespace printing