Gtk3 UI: Rename files in libgtkui containing gtk2 in their name

chrome/browser/ui/libgtkui/print_dialog_gtk.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/libgtkui/print_dialog_gtk2.h"
+#include "chrome/browser/ui/libgtkui/print_dialog_gtk.h"
 
 #include <gtk/gtkunixprint.h>
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/ui/libgtkui/gtk2_util.h"
-#include "chrome/browser/ui/libgtkui/printing_gtk2_util.h"
+#include "chrome/browser/ui/libgtkui/gtk_util.h"
+#include "chrome/browser/ui/libgtkui/printing_gtk_util.h"
 #include "printing/metafile.h"
 #include "printing/print_job_constants.h"
 #include "printing/print_settings.h"
 #include "ui/aura/window.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 
 using content::BrowserThread;
 using printing::PageRanges;
 using printing::PrintSettings;
 
@@ skipping 15 matching lines @@
 // 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) {
   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),
+                           kMicronsInMm +
+                       0.5),
       static_cast<int>(gtk_paper_size_get_height(gtk_paper_size, GTK_UNIT_MM) *
-                       kMicronsInMm + 0.5));
+                           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;
 }
@@ skipping 11 matching lines @@
     }
     if (!first_fuzzy_match && PaperSizeMatch(gtk_paper_size, media, true)) {
       first_fuzzy_match = gtk_paper_size;
     }
   }
   return first_fuzzy_match;
 }
 
 class StickyPrintSettingGtk {
  public:
-  StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {
-  }
+  StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {}
   ~StickyPrintSettingGtk() {
     NOTREACHED();  // Intended to be used with a Leaky LazyInstance.
   }
 
-  GtkPrintSettings* settings() {
-    return last_used_settings_;
-  }
+  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_;
 
@@ skipping 12 matching lines @@
 
   ~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_;
-  }
+  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 NULL;
 
     for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
          it < printers_.end(); ++it) {
@@ skipping 29 matching lines @@
     PrintingContextLinux* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return new PrintDialogGtk2(context);
 }
 
 PrintDialogGtk2::PrintDialogGtk2(PrintingContextLinux* context)
     : context_(context),
       dialog_(NULL),
       gtk_settings_(NULL),
       page_setup_(NULL),
-      printer_(NULL) {
-}
+      printer_(NULL) {}
 
 PrintDialogGtk2::~PrintDialogGtk2() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (dialog_) {
     aura::Window* parent = libgtkui::GetAuraTransientParent(dialog_);
     if (parent) {
       parent->RemoveObserver(this);
       libgtkui::ClearAuraTransientParent(dialog_);
     }
@@ skipping 97 matching lines @@
           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);
         }
-#if GTK_CHECK_VERSION(2,28,0)
+#if GTK_CHECK_VERSION(2, 28, 0)
         g_list_free_full(gtk_paper_sizes,
                          reinterpret_cast<GDestroyNotify>(gtk_paper_size_free));
 #else
         g_list_foreach(gtk_paper_sizes,
                        reinterpret_cast<GFunc>(gtk_paper_size_free), NULL);
         g_list_free(gtk_paper_sizes);
 #endif
       }
     } else {
       VLOG(1) << "Using default paper size";
     }
   }
 
   gtk_print_settings_set_orientation(
-      gtk_settings_,
-      settings->landscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE :
-                              GTK_PAGE_ORIENTATION_PORTRAIT);
+      gtk_settings_, settings->landscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE
+                                           : GTK_PAGE_ORIENTATION_PORTRAIT);
 
   InitPrintSettings(settings);
   return true;
 }
 
 void PrintDialogGtk2::ShowDialog(
     gfx::NativeView parent_view,
     bool has_selection,
     const PrintingContextLinux::PrintSettingsCallback& callback) {
   callback_ = callback;
@@ skipping 67 matching lines @@
 
   if (!success) {
     LOG(ERROR) << "Saving metafile failed";
     // Matches AddRef() above.
     Release();
     return;
   }
 
   // No errors, continue printing.
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
+      BrowserThread::UI, FROM_HERE,
       base::Bind(&PrintDialogGtk2::SendDocumentToPrinter, this, document_name));
 }
 
 void PrintDialogGtk2::AddRefToDialog() {
   AddRef();
 }
 
 void PrintDialogGtk2::ReleaseDialog() {
   Release();
 }
 
 void PrintDialogGtk2::OnResponse(GtkWidget* dialog, int response_id) {
   int num_matched_handlers = g_signal_handlers_disconnect_by_func(
       dialog_, reinterpret_cast<gpointer>(&OnResponseThunk), this);
   CHECK_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_));
+      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_));
+      page_setup_ =
+          gtk_print_unix_dialog_get_page_setup(GTK_PRINT_UNIX_DIALOG(dialog_));
       g_object_ref(page_setup_);
 
       // Handle page ranges.
       PageRanges 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);
@@ skipping 29 matching lines @@
       callback_.Reset();
       return;
     }
     case GTK_RESPONSE_DELETE_EVENT:  // Fall through.
     case GTK_RESPONSE_CANCEL: {
       callback_.Run(PrintingContextLinux::CANCEL);
       callback_.Reset();
       return;
     }
     case GTK_RESPONSE_APPLY:
-    default: {
-      NOTREACHED();
-    }
+    default: { NOTREACHED(); }
   }
 }
 
-
-
 static void OnJobCompletedThunk(GtkPrintJob* print_job,
                                 gpointer user_data,
 #if GTK_MAJOR_VERSION == 2
                                 GError* error
 #else
                                 const GError* error
 #endif
                                 ) {
   static_cast<PrintDialogGtk2*>(user_data)->OnJobCompleted(print_job, error);
 }
 void PrintDialogGtk2::SendDocumentToPrinter(
     const base::string16& document_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // If |printer_| is NULL then somehow the GTK printer list changed out under
   // us. In which case, just bail out.
   if (!printer_) {
     // Matches AddRef() in PrintDocument();
     Release();
     return;
   }
 
   // Save the settings for next time.
   g_last_used_settings.Get().SetLastUsedSettings(gtk_settings_);
 
-  GtkPrintJob* print_job = gtk_print_job_new(
-      base::UTF16ToUTF8(document_name).c_str(),
-      printer_,
-      gtk_settings_,
-      page_setup_);
+  GtkPrintJob* print_job =
+      gtk_print_job_new(base::UTF16ToUTF8(document_name).c_str(), printer_,
+                        gtk_settings_, page_setup_);
   gtk_print_job_set_source_file(print_job, path_to_pdf_.value().c_str(), NULL);
   gtk_print_job_send(print_job, OnJobCompletedThunk, this, NULL);
 }
 
 void PrintDialogGtk2::OnJobCompleted(GtkPrintJob* print_job,
                                      const GError* error) {
   if (error)
     LOG(ERROR) << "Printing failed: " << error->message;
   if (print_job)
     g_object_unref(print_job);
@@ skipping 12 matching lines @@
 void PrintDialogGtk2::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(libgtkui::GetAuraTransientParent(dialog_), window);
 
   libgtkui::ClearAuraTransientParent(dialog_);
   window->RemoveObserver(this);
   if (!callback_.is_null()) {
     callback_.Run(PrintingContextLinux::CANCEL);
     callback_.Reset();
   }
 }