text: // Copyright (c) 2014 The Chromium Embedded Framework Authors.
  // Portions 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 "tests/cefclient/browser/print_handler_gtk.h"
  
  #include <vector>
  
  #include <gtk/gtk.h>
  #include <gtk/gtkunixprint.h>
  
  #include "include/base/cef_bind.h"
  #include "include/base/cef_logging.h"
  #include "include/base/cef_macros.h"
  #include "include/wrapper/cef_helpers.h"
  
  #include "tests/cefclient/browser/root_window.h"
  #include "tests/cefclient/browser/util_gtk.h"
  
  namespace client {
  
  namespace {
  
  // CUPS Duplex attribute and values.
  const char kCUPSDuplex[] = "cups-Duplex";
  const char kDuplexNone[] = "None";
  const char kDuplexTumble[] = "DuplexTumble";
  const char kDuplexNoTumble[] = "DuplexNoTumble";
  
  // CUPS color mode attribute and values.
  const char kCUPSColorMode[] = "cups-ColorMode";
  const char kCUPSColorModel[] = "cups-ColorModel";
  const char kCUPSPrintoutMode[] = "cups-PrintoutMode";
  const char kCUPSProcessColorModel[] = "cups-ProcessColorModel";
  const char kBlack[] = "Black";
  const char kCMYK[] = "CMYK";
  const char kCMY_K[] = "CMY+K";
  const char kCMY[] = "CMY";
  const char kColor[] = "Color";
  const char kGray[] = "Gray";
  const char kGrayscale[] = "Grayscale";
  const char kGreyscale[] = "Greyscale";
  const char kMonochrome[] = "Monochrome";
  const char kNormal[] = "Normal";
  const char kNormalGray[] = "Normal.Gray";
  const char kRGB[] = "RGB";
  const char kRGBA[] = "RGBA";
  const char kRGB16[] = "RGB16";
  
  // Default margin settings.
  const double kTopMarginInInch = 0.25;
  const double kBottomMarginInInch = 0.56;
  const double kLeftMarginInInch = 0.25;
  const double kRightMarginInInch = 0.25;
  
  // Length of an inch in CSS's 1px unit.
  // http://dev.w3.org/csswg/css3-values/#the-px-unit
  const int kPixelsPerInch = 96;
  
  // LETTER: 8.5 x 11 inches
  const float kLetterWidthInch = 8.5f;
  const float kLetterHeightInch = 11.0f;
  
  class StickyPrintSettingGtk {
   public:
    StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {}
    ~StickyPrintSettingGtk() {
      NOTREACHED();  // The instance is intentionally leaked.
    }
  
    GtkPrintSettings* settings() { return last_used_settings_; }
  
    void SetLastUsedSettings(GtkPrintSettings* settings) {
      DCHECK(last_used_settings_);
      g_object_unref(last_used_settings_);
      last_used_settings_ = gtk_print_settings_copy(settings);
    }
  
   private:
    GtkPrintSettings* last_used_settings_;
  
    DISALLOW_COPY_AND_ASSIGN(StickyPrintSettingGtk);
  };
  
  // Lazily initialize the singleton instance.
  StickyPrintSettingGtk* GetLastUsedSettings() {
    static StickyPrintSettingGtk* settings = nullptr;
    if (!settings)
      settings = new StickyPrintSettingGtk();
    return settings;
  }
  
  // Helper class to track GTK printers.
  class GtkPrinterList {
   public:
    GtkPrinterList() : default_printer_(nullptr) {
      gtk_enumerate_printers(SetPrinter, this, NULL, TRUE);
    }
  
    ~GtkPrinterList() {
      for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
           it < printers_.end(); ++it) {
        g_object_unref(*it);
      }
    }
  
    // Can return NULL if there's no default printer. E.g. Printer on a laptop
    // is "home_printer", but the laptop is at work.
    GtkPrinter* default_printer() { return default_printer_; }
  
    // Can return NULL if the printer cannot be found due to:
    // - Printer list out of sync with printer dialog UI.
    // - Querying for non-existant printers like 'Print to PDF'.
    GtkPrinter* GetPrinterWithName(const std::string& name) {
      if (name.empty())
        return nullptr;
  
      for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
           it < printers_.end(); ++it) {
        if (gtk_printer_get_name(*it) == name) {
          return *it;
        }
      }
  
      return nullptr;
    }
  
   private:
    // Callback function used by gtk_enumerate_printers() to get all printer.
    static gboolean SetPrinter(GtkPrinter* printer, gpointer data) {
      GtkPrinterList* printer_list = reinterpret_cast<GtkPrinterList*>(data);
      if (gtk_printer_is_default(printer))
        printer_list->default_printer_ = printer;
  
      g_object_ref(printer);
      printer_list->printers_.push_back(printer);
  
      return FALSE;
    }
  
    std::vector<GtkPrinter*> printers_;
    GtkPrinter* default_printer_;
  };
  
  void GetColorModelForMode(CefPrintSettings::ColorModel color_mode,
                            std::string* color_setting_name,
                            std::string* color_value) {
    color_setting_name->assign(kCUPSColorModel);
    switch (color_mode) {
      case COLOR_MODEL_COLOR:
        color_value->assign(kColor);
        break;
      case COLOR_MODEL_CMYK:
        color_value->assign(kCMYK);
        break;
      case COLOR_MODEL_PRINTOUTMODE_NORMAL:
        color_value->assign(kNormal);
        color_setting_name->assign(kCUPSPrintoutMode);
        break;
      case COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY:
        color_value->assign(kNormalGray);
        color_setting_name->assign(kCUPSPrintoutMode);
        break;
      case COLOR_MODEL_RGB16:
        color_value->assign(kRGB16);
        break;
      case COLOR_MODEL_RGBA:
        color_value->assign(kRGBA);
        break;
      case COLOR_MODEL_RGB:
        color_value->assign(kRGB);
        break;
      case COLOR_MODEL_CMY:
        color_value->assign(kCMY);
        break;
      case COLOR_MODEL_CMY_K:
        color_value->assign(kCMY_K);
        break;
      case COLOR_MODEL_BLACK:
        color_value->assign(kBlack);
        break;
      case COLOR_MODEL_GRAY:
        color_value->assign(kGray);
        break;
      case COLOR_MODEL_COLORMODE_COLOR:
        color_setting_name->assign(kCUPSColorMode);
        color_value->assign(kColor);
        break;
      case COLOR_MODEL_COLORMODE_MONOCHROME:
        color_setting_name->assign(kCUPSColorMode);
        color_value->assign(kMonochrome);
        break;
      case COLOR_MODEL_HP_COLOR_COLOR:
        color_setting_name->assign(kColor);
        color_value->assign(kColor);
        break;
      case COLOR_MODEL_HP_COLOR_BLACK:
        color_setting_name->assign(kColor);
        color_value->assign(kBlack);
        break;
      case COLOR_MODEL_PROCESSCOLORMODEL_CMYK:
        color_setting_name->assign(kCUPSProcessColorModel);
        color_value->assign(kCMYK);
        break;
      case COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE:
        color_setting_name->assign(kCUPSProcessColorModel);
        color_value->assign(kGreyscale);
        break;
      case COLOR_MODEL_PROCESSCOLORMODEL_RGB:
        color_setting_name->assign(kCUPSProcessColorModel);
        color_value->assign(kRGB);
        break;
      default:
        color_value->assign(kGrayscale);
        break;
    }
  }
  
  void InitPrintSettings(GtkPrintSettings* settings,
                         GtkPageSetup* page_setup,
                         CefRefPtr<CefPrintSettings> print_settings) {
    DCHECK(settings);
    DCHECK(page_setup);
  
    std::string device_name;
    const gchar* name = gtk_print_settings_get_printer(settings);
    if (name)
      device_name = name;
    print_settings->SetDeviceName(device_name);
  
    CefSize physical_size_device_units;
    CefRect printable_area_device_units;
    int dpi = gtk_print_settings_get_resolution(settings);
    if (dpi) {
      // Initialize page_setup_device_units_.
      physical_size_device_units.Set(
          gtk_page_setup_get_paper_width(page_setup, GTK_UNIT_INCH) * dpi,
          gtk_page_setup_get_paper_height(page_setup, GTK_UNIT_INCH) * dpi);
      printable_area_device_units.Set(
          gtk_page_setup_get_left_margin(page_setup, GTK_UNIT_INCH) * dpi,
          gtk_page_setup_get_top_margin(page_setup, GTK_UNIT_INCH) * dpi,
          gtk_page_setup_get_page_width(page_setup, GTK_UNIT_INCH) * dpi,
          gtk_page_setup_get_page_height(page_setup, GTK_UNIT_INCH) * dpi);
    } else {
      // Use default values if we cannot get valid values from the print dialog.
      dpi = kPixelsPerInch;
      double page_width_in_pixel = kLetterWidthInch * dpi;
      double page_height_in_pixel = kLetterHeightInch * dpi;
      physical_size_device_units.Set(static_cast<int>(page_width_in_pixel),
                                     static_cast<int>(page_height_in_pixel));
      printable_area_device_units.Set(
          static_cast<int>(kLeftMarginInInch * dpi),
          static_cast<int>(kTopMarginInInch * dpi),
          page_width_in_pixel - (kLeftMarginInInch + kRightMarginInInch) * dpi,
          page_height_in_pixel - (kTopMarginInInch + kBottomMarginInInch) * dpi);
    }
  
    print_settings->SetDPI(dpi);
  
    // Note: With the normal GTK print dialog, when the user selects the landscape
    // orientation, all that does is change the paper size. Which seems to be
    // enough to render the right output and send it to the printer.
    // The orientation value stays as portrait and does not actually affect
    // printing.
    // Thus this is only useful in print preview mode, where we manually set the
    // orientation and change the paper size ourselves.
    GtkPageOrientation orientation = gtk_print_settings_get_orientation(settings);
    // Set before SetPrinterPrintableArea to make it flip area if necessary.
    print_settings->SetOrientation(orientation == GTK_PAGE_ORIENTATION_LANDSCAPE);
    print_settings->SetPrinterPrintableArea(physical_size_device_units,
                                            printable_area_device_units, true);
  }
  
  // Returns the GtkWindow* for the browser. Will return NULL when using the Views
  // framework.
  GtkWindow* GetWindow(CefRefPtr<CefBrowser> browser) {
    scoped_refptr<RootWindow> root_window =
        RootWindow::GetForBrowser(browser->GetIdentifier());
    if (root_window)
      return GTK_WINDOW(root_window->GetWindowHandle());
    return nullptr;
  }
  
  void RunCallback(base::Callback<void(GtkWindow*)> callback, GtkWindow* window) {
    callback.Run(window);
  }
  
  void GetWindowAndContinue(CefRefPtr<CefBrowser> browser,
                            base::Callback<void(GtkWindow*)> callback) {
    if (!CURRENTLY_ON_MAIN_THREAD()) {
      MAIN_POST_CLOSURE(base::Bind(GetWindowAndContinue, browser, callback));
      return;
    }
  
    GtkWindow* window = GetWindow(browser);
    if (window) {
      CefPostTask(TID_UI, base::Bind(RunCallback, callback, window));
    }
  }
  
  }  // namespace
  
  struct ClientPrintHandlerGtk::PrintHandler {
    PrintHandler(CefRefPtr<CefBrowser> browser)
        : browser_(browser),
          dialog_(nullptr),
          gtk_settings_(nullptr),
          page_setup_(nullptr),
          printer_(nullptr) {}
  
    ~PrintHandler() {
      ScopedGdkThreadsEnter scoped_gdk_threads;
  
      if (dialog_) {
        gtk_widget_destroy(dialog_);
        dialog_ = nullptr;
      }
      if (gtk_settings_) {
        g_object_unref(gtk_settings_);
        gtk_settings_ = nullptr;
      }
      if (page_setup_) {
        g_object_unref(page_setup_);
        page_setup_ = nullptr;
      }
      if (printer_) {
        g_object_unref(printer_);
        printer_ = nullptr;
      }
    }
  
    void OnPrintSettings(CefRefPtr<CefPrintSettings> settings,
                         bool get_defaults) {
      ScopedGdkThreadsEnter scoped_gdk_threads;
  
      if (get_defaults) {
        DCHECK(!page_setup_);
        DCHECK(!printer_);
  
        // |gtk_settings_| is a new copy.
        gtk_settings_ =
            gtk_print_settings_copy(GetLastUsedSettings()->settings());
        page_setup_ = gtk_page_setup_new();
      } else {
        if (!gtk_settings_) {
          gtk_settings_ =
              gtk_print_settings_copy(GetLastUsedSettings()->settings());
        }
  
        GtkPrinterList* printer_list = new GtkPrinterList;
        printer_ = printer_list->GetPrinterWithName(settings->GetDeviceName());
        if (printer_) {
          g_object_ref(printer_);
          gtk_print_settings_set_printer(gtk_settings_,
                                         gtk_printer_get_name(printer_));
          if (!page_setup_) {
            page_setup_ = gtk_printer_get_default_page_size(printer_);
          }
        }
  
        gtk_print_settings_set_n_copies(gtk_settings_, settings->GetCopies());
        gtk_print_settings_set_collate(gtk_settings_, settings->WillCollate());
  
        std::string color_value;
        std::string color_setting_name;
        GetColorModelForMode(settings->GetColorModel(), &color_setting_name,
                             &color_value);
        gtk_print_settings_set(gtk_settings_, color_setting_name.c_str(),
                               color_value.c_str());
  
        if (settings->GetDuplexMode() != DUPLEX_MODE_UNKNOWN) {
          const char* cups_duplex_mode = nullptr;
          switch (settings->GetDuplexMode()) {
            case DUPLEX_MODE_LONG_EDGE:
              cups_duplex_mode = kDuplexNoTumble;
              break;
            case DUPLEX_MODE_SHORT_EDGE:
              cups_duplex_mode = kDuplexTumble;
              break;
            case DUPLEX_MODE_SIMPLEX:
              cups_duplex_mode = kDuplexNone;
              break;
            default:  // UNKNOWN_DUPLEX_MODE
              NOTREACHED();
              break;
          }
          gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode);
        }
  
        if (!page_setup_)
          page_setup_ = gtk_page_setup_new();
  
        gtk_print_settings_set_orientation(gtk_settings_,
                                           settings->IsLandscape()
                                               ? GTK_PAGE_ORIENTATION_LANDSCAPE
                                               : GTK_PAGE_ORIENTATION_PORTRAIT);
  
        delete printer_list;
      }
  
      InitPrintSettings(gtk_settings_, page_setup_, settings);
    }
  
    void OnPrintDialog(bool has_selection,
                       CefRefPtr<CefPrintDialogCallback> callback,
                       GtkWindow* parent) {
      dialog_callback_ = callback;
  
      ScopedGdkThreadsEnter scoped_gdk_threads;
  
      // TODO(estade): We need a window title here.
      dialog_ = gtk_print_unix_dialog_new(NULL, parent);
      g_signal_connect(dialog_, "delete-event",
                       G_CALLBACK(gtk_widget_hide_on_delete), NULL);
  
      // Set modal so user cannot focus the same tab and press print again.
      gtk_window_set_modal(GTK_WINDOW(dialog_), TRUE);
  
      // Since we only generate PDF, only show printers that support PDF.
      // TODO(thestig) Add more capabilities to support?
      GtkPrintCapabilities cap = static_cast<GtkPrintCapabilities>(
          GTK_PRINT_CAPABILITY_GENERATE_PDF | GTK_PRINT_CAPABILITY_PAGE_SET |
          GTK_PRINT_CAPABILITY_COPIES | GTK_PRINT_CAPABILITY_COLLATE |
          GTK_PRINT_CAPABILITY_REVERSE);
      gtk_print_unix_dialog_set_manual_capabilities(
          GTK_PRINT_UNIX_DIALOG(dialog_), cap);
      gtk_print_unix_dialog_set_embed_page_setup(GTK_PRINT_UNIX_DIALOG(dialog_),
                                                 TRUE);
      gtk_print_unix_dialog_set_support_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
                                                  TRUE);
      gtk_print_unix_dialog_set_has_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
                                              has_selection);
      gtk_print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(dialog_),
                                         gtk_settings_);
      g_signal_connect(dialog_, "response", G_CALLBACK(OnDialogResponseThunk),
                       this);
      gtk_widget_show(dialog_);
    }
  
    bool OnPrintJob(const CefString& document_name,
                    const CefString& pdf_file_path,
                    CefRefPtr<CefPrintJobCallback> callback) {
      // If |printer_| is NULL then somehow the GTK printer list changed out under
      // us. In which case, just bail out.
      if (!printer_)
        return false;
  
      ScopedGdkThreadsEnter scoped_gdk_threads;
  
      job_callback_ = callback;
  
      // Save the settings for next time.
      GetLastUsedSettings()->SetLastUsedSettings(gtk_settings_);
  
      GtkPrintJob* print_job = gtk_print_job_new(
          document_name.ToString().c_str(), printer_, gtk_settings_, page_setup_);
      gtk_print_job_set_source_file(print_job, pdf_file_path.ToString().c_str(),
                                    NULL);
      gtk_print_job_send(print_job, OnJobCompletedThunk, this, NULL);
  
      return true;
    }
  
   private:
    void OnDialogResponse(GtkDialog* dialog, gint response_id) {
      int num_matched_handlers = g_signal_handlers_disconnect_by_func(
          dialog_, reinterpret_cast<gpointer>(&OnDialogResponseThunk), this);
      DCHECK_EQ(1, num_matched_handlers);
  
      gtk_widget_hide(dialog_);
  
      switch (response_id) {
        case GTK_RESPONSE_OK: {
          if (gtk_settings_)
            g_object_unref(gtk_settings_);
          gtk_settings_ =
              gtk_print_unix_dialog_get_settings(GTK_PRINT_UNIX_DIALOG(dialog_));
  
          if (printer_)
            g_object_unref(printer_);
          printer_ = gtk_print_unix_dialog_get_selected_printer(
              GTK_PRINT_UNIX_DIALOG(dialog_));
          g_object_ref(printer_);
  
          if (page_setup_)
            g_object_unref(page_setup_);
          page_setup_ = gtk_print_unix_dialog_get_page_setup(
              GTK_PRINT_UNIX_DIALOG(dialog_));
          g_object_ref(page_setup_);
  
          // Handle page ranges.
          CefPrintSettings::PageRangeList ranges_vector;
          gint num_ranges;
          bool print_selection_only = false;
          switch (gtk_print_settings_get_print_pages(gtk_settings_)) {
            case GTK_PRINT_PAGES_RANGES: {
              GtkPageRange* gtk_range =
                  gtk_print_settings_get_page_ranges(gtk_settings_, &num_ranges);
              if (gtk_range) {
                for (int i = 0; i < num_ranges; ++i) {
                  ranges_vector.push_back(
                      CefRange(gtk_range[i].start, gtk_range[i].end));
                }
                g_free(gtk_range);
              }
              break;
            }
            case GTK_PRINT_PAGES_SELECTION:
              print_selection_only = true;
              break;
            case GTK_PRINT_PAGES_ALL:
              // Leave |ranges_vector| empty to indicate print all pages.
              break;
            case GTK_PRINT_PAGES_CURRENT:
            default:
              NOTREACHED();
              break;
          }
  
          CefRefPtr<CefPrintSettings> settings = CefPrintSettings::Create();
          settings->SetPageRanges(ranges_vector);
          settings->SetSelectionOnly(print_selection_only);
          InitPrintSettings(gtk_settings_, page_setup_, settings);
          dialog_callback_->Continue(settings);
          dialog_callback_ = nullptr;
          return;
        }
        case GTK_RESPONSE_DELETE_EVENT:  // Fall through.
        case GTK_RESPONSE_CANCEL: {
          dialog_callback_->Cancel();
          dialog_callback_ = nullptr;
          return;
        }
        case GTK_RESPONSE_APPLY:
        default: {
          NOTREACHED();
        }
      }
    }
  
    void OnJobCompleted(GtkPrintJob* print_job, const GError* error) {
      // Continue() will result in a call to ClientPrintHandlerGtk::OnPrintReset
      // which deletes |this|. Execute it asnychronously so the call stack has a
      // chance to unwind.
      CefPostTask(TID_UI, base::Bind(&CefPrintJobCallback::Continue,
                                     job_callback_.get()));
      job_callback_ = nullptr;
    }
  
    static void OnDialogResponseThunk(GtkDialog* dialog,
                                      gint response_id,
                                      PrintHandler* handler) {
      handler->OnDialogResponse(dialog, response_id);
    }
  
    static void OnJobCompletedThunk(GtkPrintJob* print_job,
                                    void* handler,
                                    const GError* error) {
      static_cast<PrintHandler*>(handler)->OnJobCompleted(print_job, error);
    }
  
    CefRefPtr<CefBrowser> browser_;
  
    GtkWidget* dialog_;               // Owned.
    GtkPrintSettings* gtk_settings_;  // Referenced.
    GtkPageSetup* page_setup_;        // Referenced.
    GtkPrinter* printer_;             // Referenced.
  
    CefRefPtr<CefPrintDialogCallback> dialog_callback_;
    CefRefPtr<CefPrintJobCallback> job_callback_;
  };
  
  ClientPrintHandlerGtk::ClientPrintHandlerGtk() {}
  
  ClientPrintHandlerGtk::~ClientPrintHandlerGtk() {
    DCHECK(print_handler_map_.empty());
  }
  
  void ClientPrintHandlerGtk::OnPrintStart(CefRefPtr<CefBrowser> browser) {
    CEF_REQUIRE_UI_THREAD();
  
    const int browser_id = browser->GetIdentifier();
  
  #ifndef _NDEBUG
    // Print handler should not already exist for the browser.
    PrintHandlerMap::const_iterator it = print_handler_map_.find(browser_id);
    DCHECK(it == print_handler_map_.end());
  #endif
  
    // Create a new print handler.
    PrintHandler* ph = new PrintHandler(browser);
    print_handler_map_.insert(std::make_pair(browser_id, ph));
  }
  
  void ClientPrintHandlerGtk::OnPrintSettings(
      CefRefPtr<CefBrowser> browser,
      CefRefPtr<CefPrintSettings> settings,
      bool get_defaults) {
    CEF_REQUIRE_UI_THREAD();
  
    GetPrintHandler(browser)->OnPrintSettings(settings, get_defaults);
  }
  
  bool ClientPrintHandlerGtk::OnPrintDialog(
      CefRefPtr<CefBrowser> browser,
      bool has_selection,
      CefRefPtr<CefPrintDialogCallback> callback) {
    CEF_REQUIRE_UI_THREAD();
  
    PrintHandler* print_handler = GetPrintHandler(browser);
    GetWindowAndContinue(browser, base::Bind(&PrintHandler::OnPrintDialog,
                                             base::Unretained(print_handler),
                                             has_selection, callback));
    return true;
  }
  
  bool ClientPrintHandlerGtk::OnPrintJob(
      CefRefPtr<CefBrowser> browser,
      const CefString& document_name,
      const CefString& pdf_file_path,
      CefRefPtr<CefPrintJobCallback> callback) {
    CEF_REQUIRE_UI_THREAD();
  
    return GetPrintHandler(browser)->OnPrintJob(document_name, pdf_file_path,
                                                callback);
  }
  
  void ClientPrintHandlerGtk::OnPrintReset(CefRefPtr<CefBrowser> browser) {
    CEF_REQUIRE_UI_THREAD();
  
    // Delete the print handler.
    PrintHandlerMap::iterator it =
        print_handler_map_.find(browser->GetIdentifier());
    DCHECK(it != print_handler_map_.end());
    delete it->second;
    print_handler_map_.erase(it);
  }
  
  CefSize ClientPrintHandlerGtk::GetPdfPaperSize(int device_units_per_inch) {
    CEF_REQUIRE_UI_THREAD();
  
    ScopedGdkThreadsEnter scoped_gdk_threads;
  
    GtkPageSetup* page_setup = gtk_page_setup_new();
  
    float width = gtk_page_setup_get_paper_width(page_setup, GTK_UNIT_INCH);
    float height = gtk_page_setup_get_paper_height(page_setup, GTK_UNIT_INCH);
  
    g_object_unref(page_setup);
  
    return CefSize(width * device_units_per_inch, height * device_units_per_inch);
  }
  
  ClientPrintHandlerGtk::PrintHandler* ClientPrintHandlerGtk::GetPrintHandler(
      CefRefPtr<CefBrowser> browser) {
    PrintHandlerMap::const_iterator it =
        print_handler_map_.find(browser->GetIdentifier());
    DCHECK(it != print_handler_map_.end());
    return it->second;
  }
  
  }  // namespace client
  