Gtk: Change NULL to nullptr

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_gtk.h"
 
 #include <gtk/gtkunixprint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 54 matching lines @@
       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
+// media in the paper size list reported by GTK. Returns nullptr if there's no
 // match found.
 GtkPaperSize* FindPaperSizeMatch(GList* gtk_paper_sizes,
                                  const PrintSettings::RequestedMedia& media) {
-  GtkPaperSize* first_fuzzy_match = NULL;
+  GtkPaperSize* first_fuzzy_match = nullptr;
   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 (!first_fuzzy_match && PaperSizeMatch(gtk_paper_size, media, true)) {
       first_fuzzy_match = gtk_paper_size;
     }
   }
   return first_fuzzy_match;
@@ skipping 19 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StickyPrintSettingGtk);
 };
 
 base::LazyInstance<StickyPrintSettingGtk>::Leaky g_last_used_settings =
     LAZY_INSTANCE_INITIALIZER;
 
 // Helper class to track GTK printers.
 class GtkPrinterList {
  public:
-  GtkPrinterList() : default_printer_(NULL) {
-    gtk_enumerate_printers(SetPrinter, this, NULL, TRUE);
+  GtkPrinterList() : default_printer_(nullptr) {
+    gtk_enumerate_printers(SetPrinter, this, nullptr, 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
+  // Can return nullptr 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:
+  // Can return nullptr 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;
+      return nullptr;
 
     for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
          it < printers_.end(); ++it) {
       if (gtk_printer_get_name(*it) == name) {
         return *it;
       }
     }
 
-    return NULL;
+    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);
@@ skipping 10 matching lines @@
 
 // static
 printing::PrintDialogGtkInterface* PrintDialogGtk2::CreatePrintDialog(
     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) {}
+      dialog_(nullptr),
+      gtk_settings_(nullptr),
+      page_setup_(nullptr),
+      printer_(nullptr) {}
 
 PrintDialogGtk2::~PrintDialogGtk2() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (dialog_) {
     aura::Window* parent = libgtkui::GetAuraTransientParent(dialog_);
     if (parent) {
       parent->RemoveObserver(this);
       libgtkui::ClearAuraTransientParent(dialog_);
     }
     gtk_widget_destroy(dialog_);
-    dialog_ = NULL;
+    dialog_ = nullptr;
   }
   if (gtk_settings_) {
     g_object_unref(gtk_settings_);
-    gtk_settings_ = NULL;
+    gtk_settings_ = nullptr;
   }
   if (page_setup_) {
     g_object_unref(page_setup_);
-    page_setup_ = NULL;
+    page_setup_ = nullptr;
   }
   if (printer_) {
     g_object_unref(printer_);
-    printer_ = NULL;
+    printer_ = nullptr;
   }
 }
 
 void PrintDialogGtk2::UseDefaultSettings() {
   DCHECK(!page_setup_);
   DCHECK(!printer_);
 
   // |gtk_settings_| is a new copy.
   gtk_settings_ =
       gtk_print_settings_copy(g_last_used_settings.Get().settings());
@@ skipping 26 matching lines @@
 
 #if defined(USE_CUPS)
   std::string color_value;
   std::string color_setting_name;
   printing::GetColorModelForMode(settings->color(), &color_setting_name,
                                  &color_value);
   gtk_print_settings_set(gtk_settings_, color_setting_name.c_str(),
                          color_value.c_str());
 
   if (settings->duplex_mode() != printing::UNKNOWN_DUPLEX_MODE) {
-    const char* cups_duplex_mode = NULL;
+    const char* cups_duplex_mode = nullptr;
     switch (settings->duplex_mode()) {
       case printing::LONG_EDGE:
         cups_duplex_mode = kDuplexNoTumble;
         break;
       case printing::SHORT_EDGE:
         cups_duplex_mode = kDuplexTumble;
         break;
       case printing::SIMPLEX:
         cups_duplex_mode = kDuplexNone;
         break;
@@ skipping 31 matching lines @@
               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)
         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);
+                       reinterpret_cast<GFunc>(gtk_paper_size_free), nullptr);
         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);
 
   InitPrintSettings(settings);
   return true;
 }
 
 void PrintDialogGtk2::ShowDialog(
     gfx::NativeView parent_view,
     bool has_selection,
     const PrintingContextLinux::PrintSettingsCallback& callback) {
   callback_ = callback;
   DCHECK(!callback_.is_null());
 
-  dialog_ = gtk_print_unix_dialog_new(NULL, NULL);
+  dialog_ = gtk_print_unix_dialog_new(nullptr, nullptr);
   libgtkui::SetGtkTransientForAura(dialog_, parent_view);
   if (parent_view)
     parent_view->AddObserver(this);
   g_signal_connect(dialog_, "delete-event",
-                   G_CALLBACK(gtk_widget_hide_on_delete), NULL);
+                   G_CALLBACK(gtk_widget_hide_on_delete), nullptr);
 
   // Handle the case when the existing |gtk_settings_| has "selection" selected
   // as the page range, but |has_selection| is false.
   if (!has_selection) {
     GtkPrintPages range = gtk_print_settings_get_print_pages(gtk_settings_);
     if (range == GTK_PRINT_PAGES_SELECTION)
       gtk_print_settings_set_print_pages(gtk_settings_, GTK_PRINT_PAGES_ALL);
   }
 
   // Set modal so user cannot focus the same tab and press print again.
@@ skipping 152 matching lines @@
 #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_| is nullptr 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_);
-  gtk_print_job_set_source_file(print_job, path_to_pdf_.value().c_str(), NULL);
-  gtk_print_job_send(print_job, OnJobCompletedThunk, this, NULL);
+  gtk_print_job_set_source_file(print_job, path_to_pdf_.value().c_str(),
+                                nullptr);
+  gtk_print_job_send(print_job, OnJobCompletedThunk, this, nullptr);
 }
 
 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);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
@@ skipping 10 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();
   }
 }