Gtk: Change NULL to nullptr

chrome/browser/ui/libgtkui/select_file_dialog_impl_gtk.cc

 // 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 "chrome/browser/ui/libgtkui/select_file_dialog_impl_gtk.h"
 
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 #include <stddef.h>
 #include <sys/stat.h>
@@ skipping 58 matching lines @@
 static const int kPreviewHeight = 512;
 
 SelectFileDialogImpl* SelectFileDialogImpl::NewSelectFileDialogImplGTK(
     Listener* listener,
     ui::SelectFilePolicy* policy) {
   return new SelectFileDialogImplGTK(listener, policy);
 }
 
 SelectFileDialogImplGTK::SelectFileDialogImplGTK(Listener* listener,
                                                  ui::SelectFilePolicy* policy)
-    : SelectFileDialogImpl(listener, policy), preview_(NULL) {}
+    : SelectFileDialogImpl(listener, policy), preview_(nullptr) {}
 
 SelectFileDialogImplGTK::~SelectFileDialogImplGTK() {
   for (std::set<aura::Window*>::iterator iter = parents_.begin();
        iter != parents_.end(); ++iter) {
     (*iter)->RemoveObserver(this);
   }
   while (dialogs_.begin() != dialogs_.end()) {
     gtk_widget_destroy(*(dialogs_.begin()));
   }
 }
@@ skipping 37 matching lines @@
     owning_window->AddObserver(this);
     parents_.insert(owning_window);
   }
 
   std::string title_string = base::UTF16ToUTF8(title);
 
   file_type_index_ = file_type_index;
   if (file_types)
     file_types_ = *file_types;
 
-  GtkWidget* dialog = NULL;
+  GtkWidget* dialog = nullptr;
   switch (type) {
     case SELECT_FOLDER:
     case SELECT_UPLOAD_FOLDER:
       dialog = CreateSelectFolderDialog(type, title_string, default_path,
                                         owning_window);
       break;
     case SELECT_OPEN_FILE:
       dialog = CreateFileOpenDialog(title_string, default_path, owning_window);
       break;
     case SELECT_OPEN_MULTI_FILE:
       dialog =
           CreateMultiFileOpenDialog(title_string, default_path, owning_window);
       break;
     case SELECT_SAVEAS_FILE:
       dialog = CreateSaveAsDialog(title_string, default_path, owning_window);
       break;
     default:
       NOTREACHED();
       return;
   }
   g_signal_connect(dialog, "delete-event",
-                   G_CALLBACK(gtk_widget_hide_on_delete), NULL);
+                   G_CALLBACK(gtk_widget_hide_on_delete), nullptr);
   dialogs_.insert(dialog);
 
   preview_ = gtk_image_new();
   g_signal_connect(dialog, "destroy", G_CALLBACK(OnFileChooserDestroyThunk),
                    this);
   g_signal_connect(dialog, "update-preview", G_CALLBACK(OnUpdatePreviewThunk),
                    this);
   gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), preview_);
 
   params_map_[dialog] = params;
@@ skipping 20 matching lines @@
   gtk_widget_show_all(dialog);
 
   // We need to call gtk_window_present after making the widgets visible to make
   // sure window gets correctly raised and gets focus.
   gtk_window_present_with_time(
       GTK_WINDOW(dialog), ui::X11EventSource::GetInstance()->GetTimestamp());
 }
 
 void SelectFileDialogImplGTK::AddFilters(GtkFileChooser* chooser) {
   for (size_t i = 0; i < file_types_.extensions.size(); ++i) {
-    GtkFileFilter* filter = NULL;
+    GtkFileFilter* filter = nullptr;
     std::set<std::string> fallback_labels;
 
     for (size_t j = 0; j < file_types_.extensions[i].size(); ++j) {
       const std::string& current_extension = file_types_.extensions[i][j];
       if (!current_extension.empty()) {
         if (!filter)
           filter = gtk_file_filter_new();
         std::unique_ptr<std::string> file_extension(
             new std::string("." + current_extension));
         fallback_labels.insert(std::string("*").append(*file_extension));
@@ skipping 78 matching lines @@
   if (listener_)
     listener_->FileSelectionCanceled(params);
   gtk_widget_destroy(dialog);
 }
 
 GtkWidget* SelectFileDialogImplGTK::CreateFileOpenHelper(
     const std::string& title,
     const base::FilePath& default_path,
     gfx::NativeWindow parent) {
   GtkWidget* dialog = gtk_file_chooser_dialog_new(
-      title.c_str(), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel",
+      title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel",
       GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, nullptr);
   SetGtkTransientForAura(dialog, parent);
   AddFilters(GTK_FILE_CHOOSER(dialog));
 
   if (!default_path.empty()) {
     if (CallDirectoryExistsOnUIThread(default_path)) {
       gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                           default_path.value().c_str());
     } else {
       // If the file doesn't exist, this will just switch to the correct
@@ skipping 20 matching lines @@
             ? l10n_util::GetStringUTF8(IDS_SELECT_UPLOAD_FOLDER_DIALOG_TITLE)
             : l10n_util::GetStringUTF8(IDS_SELECT_FOLDER_DIALOG_TITLE);
   }
   std::string accept_button_label =
       (type == SELECT_UPLOAD_FOLDER)
           ? l10n_util::GetStringUTF8(
                 IDS_SELECT_UPLOAD_FOLDER_DIALOG_UPLOAD_BUTTON)
           : "_Open";
 
   GtkWidget* dialog = gtk_file_chooser_dialog_new(
-      title_string.c_str(), NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+      title_string.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
       "_Cancel", GTK_RESPONSE_CANCEL, accept_button_label.c_str(),
       GTK_RESPONSE_ACCEPT, nullptr);
   SetGtkTransientForAura(dialog, parent);
 
   if (!default_path.empty()) {
     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
                                   default_path.value().c_str());
   } else if (!last_opened_path_->empty()) {
     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                         last_opened_path_->value().c_str());
@@ skipping 36 matching lines @@
 
 GtkWidget* SelectFileDialogImplGTK::CreateSaveAsDialog(
     const std::string& title,
     const base::FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string =
       !title.empty() ? title
                      : l10n_util::GetStringUTF8(IDS_SAVE_AS_DIALOG_TITLE);
 
   GtkWidget* dialog = gtk_file_chooser_dialog_new(
-      title_string.c_str(), NULL, GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel",
+      title_string.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel",
       GTK_RESPONSE_CANCEL, "_Save", GTK_RESPONSE_ACCEPT, nullptr);
   SetGtkTransientForAura(dialog, parent);
 
   AddFilters(GTK_FILE_CHOOSER(dialog));
   if (!default_path.empty()) {
     if (CallDirectoryExistsOnUIThread(default_path)) {
       // If this is an existing directory, navigate to that directory, with no
       // filename.
       gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                           default_path.value().c_str());
@@ skipping 83 matching lines @@
     return;
   }
 
   GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
   if (!filenames) {
     FileNotSelected(dialog);
     return;
   }
 
   std::vector<base::FilePath> filenames_fp;
-  for (GSList* iter = filenames; iter != NULL; iter = g_slist_next(iter)) {
+  for (GSList* iter = filenames; iter != nullptr; iter = g_slist_next(iter)) {
     base::FilePath path(static_cast<char*>(iter->data));
     g_free(iter->data);
     if (CallDirectoryExistsOnUIThread(path))
       continue;
     filenames_fp.push_back(path);
   }
   g_slist_free(filenames);
 
   if (filenames_fp.empty()) {
     FileNotSelected(dialog);
     return;
   }
   MultiFilesSelected(dialog, filenames_fp);
 }
 
 void SelectFileDialogImplGTK::OnFileChooserDestroy(GtkWidget* dialog) {
   dialogs_.erase(dialog);
 
-  // |parent| can be NULL when closing the host window
+  // |parent| can be nullptr when closing the host window
   // while opening the file-picker.
   aura::Window* parent = GetAuraTransientParent(dialog);
   if (!parent)
     return;
   std::set<aura::Window*>::iterator iter = parents_.find(parent);
   if (iter != parents_.end()) {
     (*iter)->RemoveObserver(this);
     parents_.erase(iter);
   } else {
     NOTREACHED();
@@ skipping 14 matching lines @@
   struct stat stat_buf;
   if (stat(filename, &stat_buf) != 0 || !S_ISREG(stat_buf.st_mode)) {
     g_free(filename);
     gtk_file_chooser_set_preview_widget_active(GTK_FILE_CHOOSER(chooser),
                                                FALSE);
     return;
   }
 
   // This will preserve the image's aspect ratio.
   GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_size(filename, kPreviewWidth,
-                                                       kPreviewHeight, NULL);
+                                                       kPreviewHeight, nullptr);
   g_free(filename);
   if (pixbuf) {
     gtk_image_set_from_pixbuf(GTK_IMAGE(preview_), pixbuf);
     g_object_unref(pixbuf);
   }
   gtk_file_chooser_set_preview_widget_active(GTK_FILE_CHOOSER(chooser),
                                              pixbuf ? TRUE : FALSE);
 }
 
 }  // namespace libgtkui