Gtk: Change NULL to nullptr

chrome/browser/ui/libgtkui/menu_util.cc

 // Copyright 2013 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/menu_util.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/libgtkui/gtk_util.h"
 #include "chrome/browser/ui/libgtkui/skia_utils_gtk.h"
@@ skipping 55 matching lines @@
       gtk_widget_show(menu_item);
   } else {
     gtk_widget_show(menu_item);
   }
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
   return menu_item;
 }
 
 bool GetMenuItemID(GtkWidget* menu_item, int* menu_id) {
   gpointer id_ptr = g_object_get_data(G_OBJECT(menu_item), "menu-id");
-  if (id_ptr != NULL) {
+  if (id_ptr != nullptr) {
     *menu_id = GPOINTER_TO_INT(id_ptr) - 1;
     return true;
   }
 
   return false;
 }
 
 void ExecuteCommand(ui::MenuModel* model, int id) {
   GdkEvent* event = gtk_get_current_event();
   int event_flags = 0;
 
   if (event && event->type == GDK_BUTTON_RELEASE)
     event_flags = EventFlagsFromGdkState(event->button.state);
   model->ActivatedAt(id, event_flags);
 
   if (event)
     gdk_event_free(event);
 }
 
 void BuildSubmenuFromModel(ui::MenuModel* model,
                            GtkWidget* menu,
                            GCallback item_activated_cb,
                            bool* block_activation,
                            void* this_ptr) {
   std::map<int, GtkWidget*> radio_groups;
-  GtkWidget* menu_item = NULL;
+  GtkWidget* menu_item = nullptr;
   for (int i = 0; i < model->GetItemCount(); ++i) {
     gfx::Image icon;
     std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
         base::UTF16ToUTF8(model->GetLabelAt(i)));
 
     bool connect_to_activate = true;
 
     switch (model->GetTypeAt(i)) {
       case ui::MenuModel::TYPE_SEPARATOR:
         menu_item = gtk_separator_menu_item_new();
         break;
 
       case ui::MenuModel::TYPE_CHECK:
         menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
         break;
 
       case ui::MenuModel::TYPE_RADIO: {
         std::map<int, GtkWidget*>::iterator iter =
             radio_groups.find(model->GetGroupIdAt(i));
 
         if (iter == radio_groups.end()) {
           menu_item =
-              gtk_radio_menu_item_new_with_mnemonic(NULL, label.c_str());
+              gtk_radio_menu_item_new_with_mnemonic(nullptr, label.c_str());
           radio_groups[model->GetGroupIdAt(i)] = menu_item;
         } else {
           menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget(
               GTK_RADIO_MENU_ITEM(iter->second), label.c_str());
         }
         break;
       }
       case ui::MenuModel::TYPE_BUTTON_ITEM: {
         NOTIMPLEMENTED();
         break;
@@ skipping 27 matching lines @@
 
       // Update all the menu item info in the newly-generated menu.
       gtk_container_foreach(
           GTK_CONTAINER(submenu), SetMenuItemInfo, block_activation);
       submenu_model->MenuWillShow();
       connect_to_activate = false;
     }
 
     ui::Accelerator accelerator;
     if (model->GetAcceleratorAt(i, &accelerator)) {
-      gtk_widget_add_accelerator(menu_item,
-                                 "activate",
-                                 NULL,
+      gtk_widget_add_accelerator(menu_item, "activate", nullptr,
                                  GetGdkKeyCodeForAccelerator(accelerator),
                                  GetGdkModifierForAccelerator(accelerator),
                                  GTK_ACCEL_VISIBLE);
     }
 
     g_object_set_data(G_OBJECT(menu_item), "model", model);
     AppendMenuItemToMenu(i,
                          model,
                          menu_item,
                          menu,
                          connect_to_activate,
                          item_activated_cb,
                          this_ptr);
 
-    menu_item = NULL;
+    menu_item = nullptr;
   }
 }
 
 void SetMenuItemInfo(GtkWidget* widget, void* block_activation_ptr) {
   if (GTK_IS_SEPARATOR_MENU_ITEM(widget)) {
     // We need to explicitly handle this case because otherwise we'll ask the
     // menu delegate about something with an invalid id.
     return;
   }
 
@@ skipping 35 matching lines @@
 
         gtk_menu_item_set_label(GTK_MENU_ITEM(widget), label.c_str());
         if (GTK_IS_IMAGE_MENU_ITEM(widget)) {
           gfx::Image icon;
           if (model->GetIconAt(id, &icon)) {
             GdkPixbuf* pixbuf = GdkPixbufFromSkBitmap(*icon.ToSkBitmap());
             gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget),
                 gtk_image_new_from_pixbuf(pixbuf));
             g_object_unref(pixbuf);
           } else {
-            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), NULL);
+            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), nullptr);
           }
         }
       }
 
       gtk_widget_show(widget);
     } else {
       gtk_widget_hide(widget);
     }
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(
           GTK_CONTAINER(submenu), &SetMenuItemInfo, block_activation_ptr);
     }
   }
 }
 
 }  // namespace libgtkui