Add paper size reporting for CUPS printers (to let user to select one in the Print Preview).

chrome/browser/ui/libgtk2ui/print_dialog_gtk2.cc

 // Copyright 2014 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 "chrome/browser/ui/libgtk2ui/print_dialog_gtk2.h"
 
 #include <gtk/gtkunixprint.h>
 
+#include <algorithm>
+#include <cmath>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 10 matching lines @@
 using printing::PrintSettings;
 
 namespace {
 
 // CUPS Duplex attribute and values.
 const char kCUPSDuplex[] = "cups-Duplex";
 const char kDuplexNone[] = "None";
 const char kDuplexTumble[] = "DuplexTumble";
 const char kDuplexNoTumble[] = "DuplexNoTumble";
 
+int kPaperSizeTresholdMicrons = 100;
+int kMicronsInMm = 1000;
+
+// Checks whether gtk_paper_size can be used to represent user selected media.
+// In fuzzy match mode checks that paper sizes are "close enough" (less than
+// 1mm difference). In the exact mode, looks for the paper with the same PPD
+// name and "close enough" size.
+bool PaperSizeMatch(GtkPaperSize* gtk_paper_size,
+                    const PrintSettings::RequestedMedia& media,
+                    bool fuzzy_match) {

[Vitaly Buka (NO REVIEWS), 2014/06/12 19:32:51]

fuzzy_match -> size_only_match?

[Aleksey Shlyapnikov, 2014/06/12 21:21:12]

I think fuzzy_match conveys the purpose better.

[Vitaly Buka (NO REVIEWS), 2014/06/12 21:34:07]

fuzzy is good when you can't explain logic.
Here is size only match.

On 2014/06/12 21:21:12, Aleksey Shlyapnikov wrote:

[Aleksey Shlyapnikov, 2014/06/12 22:56:33]

Here it also means "ignore PPD name".

[Vitaly Buka (NO REVIEWS), 2014/06/12 23:06:04]

Thanks.

On 2014/06/12 22:56:33, Aleksey Shlyapnikov wrote:

+  if (!gtk_paper_size) {
+    return false;
+  }
+  gfx::Size paper_size_microns(
+      static_cast<int>(gtk_paper_size_get_width(gtk_paper_size, GTK_UNIT_MM) *
+                       kMicronsInMm + 0.5),
+      static_cast<int>(gtk_paper_size_get_height(gtk_paper_size, GTK_UNIT_MM) *
+                       kMicronsInMm + 0.5));
+  int diff = std::max(
+      std::abs(paper_size_microns.width() - media.size_microns.width()),
+      std::abs(paper_size_microns.height() - media.size_microns.height()));
+  if (fuzzy_match) {
+    return diff <= kPaperSizeTresholdMicrons;
+  }
+  return !media.vendor_id.empty() &&
+         media.vendor_id == gtk_paper_size_get_ppd_name(gtk_paper_size) &&
+         diff <= kPaperSizeTresholdMicrons;
+}
+
+// Looks up a paper size matching (in terms of PaperSizeMatch) the user selected
+// media in the paper size list reported by GTK. Returns NULL if there's no
+// match found.
+GtkPaperSize* FindPaperSizeMatch(GList* gtk_paper_sizes,
+                                 const PrintSettings::RequestedMedia& media,
+                                 bool fuzzy_match) {
+  for (GList* p = gtk_paper_sizes; p && p->data; p = g_list_next(p)) {
+    GtkPaperSize* gtk_paper_size = static_cast<GtkPaperSize*>(p->data);
+    if (PaperSizeMatch(gtk_paper_size, media, fuzzy_match)) {

[Vitaly Buka (NO REVIEWS), 2014/06/12 19:32:51]

No need for arg bool fuzzy_match

GtkPaperSize* fuzzy_matched = NULL;
for (GList* p = gtk_paper_sizes; p && p->data; p = g_list_next(p)) {
       GtkPaperSize* gtk_paper_size = static_cast<GtkPaperSize*>(p->data);
       if (PaperSizeMatch(gtk_paper_size, media, false)) {
         return gtk_paper_size;
       }
       if (!fuzzy_matched && PaperSizeMatch(gtk_paper_size, media, true)) {
         return fuzzy_matched = gtk_paper_size;
       }
     }
     return fuzzy_matched;
   }

[Aleksey Shlyapnikov, 2014/06/12 21:21:12]

It changes the semantics. My idea is to traverse the entire list first looking
for the exact match and only if it fails, look for the fuzzy match. In your
version we'll stop of first fuzzy match, even if there's a perfect match further
down the list.

[Vitaly Buka (NO REVIEWS), 2014/06/12 21:34:08]

Semantic exactly the same.
It just remember fuzzy match and returns it only if no exact match is possible.

On 2014/06/12 21:21:12, Aleksey Shlyapnikov wrote:

[Aleksey Shlyapnikov, 2014/06/12 22:56:33]

Addressed your concern.

+      return gtk_paper_size;
+    }
+  }
+  return NULL;
+}
+
 class StickyPrintSettingGtk {
  public:
   StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {
   }
   ~StickyPrintSettingGtk() {
     NOTREACHED();  // Intended to be used with a Leaky LazyInstance.
   }
 
   GtkPrintSettings* settings() {
     return last_used_settings_;
@@ skipping 168 matching lines @@
       default:  // UNKNOWN_DUPLEX_MODE
         NOTREACHED();
         break;
     }
     gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode);
   }
 #endif
   if (!page_setup_)
     page_setup_ = gtk_page_setup_new();
 
+  if (page_setup_ && !settings->requested_media().IsDefault()) {
+    const PrintSettings::RequestedMedia& requested_media =
+        settings->requested_media();
+    GtkPaperSize* gtk_current_paper_size =
+        gtk_page_setup_get_paper_size(page_setup_);
+    if (!PaperSizeMatch(gtk_current_paper_size, requested_media,
+                        true /*fuzzy_match*/)) {
+      GList* gtk_paper_sizes =
+          gtk_paper_size_get_paper_sizes(false /*include_custom*/);
+      if (gtk_paper_sizes) {
+        GtkPaperSize* matching_gtk_paper_size = FindPaperSizeMatch(
+            gtk_paper_sizes, requested_media, false /*fuzzy_match*/);
+        if (!matching_gtk_paper_size) {
+          matching_gtk_paper_size = FindPaperSizeMatch(
+              gtk_paper_sizes, requested_media, true /*fuzzy_match*/);
+        }
+        if (matching_gtk_paper_size) {
+          VLOG(1) << "Using listed paper size";
+          gtk_page_setup_set_paper_size(page_setup_, matching_gtk_paper_size);
+        } else {
+          VLOG(1) << "Using custom paper size";
+          GtkPaperSize* custom_size = gtk_paper_size_new_custom(
+              requested_media.vendor_id.c_str(),
+              requested_media.vendor_id.c_str(),
+              requested_media.size_microns.width() / kMicronsInMm,
+              requested_media.size_microns.height() / kMicronsInMm,
+              GTK_UNIT_MM);
+          gtk_page_setup_set_paper_size(page_setup_, custom_size);
+          gtk_paper_size_free(custom_size);
+        }
+        g_list_free_full(gtk_paper_sizes,
+                         reinterpret_cast<GDestroyNotify>(gtk_paper_size_free));
+      }
+    } else {
+      VLOG(1) << "Using default paper size";
+    }
+  }
+
   gtk_print_settings_set_orientation(
       gtk_settings_,
       settings->landscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE :
                               GTK_PAGE_ORIENTATION_PORTRAIT);
 
   InitPrintSettings(settings);
   return true;
 }
 
 void PrintDialogGtk2::ShowDialog(
@@ skipping 205 matching lines @@
   context_->InitWithSettings(*settings);
 }
 
 void PrintDialogGtk2::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(libgtk2ui::GetAuraTransientParent(dialog_), window);
 
   libgtk2ui::ClearAuraTransientParent(dialog_);
   window->RemoveObserver(this);
   Release();
 }