Removing PS option from PdfPsMetafile

printing/pdf_ps_metafile_cairo.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 {
 
@@ skipping 18 matching lines @@
 }
 
 // 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.
+// Callback function for Cairo to write PDF 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) {
+    : 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.
+  // Creates an 1 by 1 Cairo surface for the entire PDF 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;
-  }
+  surface_ = cairo_pdf_surface_create_for_stream(WriteCairoStream,
+                                                 &data_, 1, 1);
 
   // 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.
@@ skipping 60 matching lines @@
   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;
-  }
-
+  cairo_pdf_surface_set_size(surface_, width, height);
   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 we have raw PDF 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_);
 }
 
@@ skipping 53 matching lines @@
   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