Gtk: Change NULL to nullptr

chrome/browser/ui/libgtkui/x11_input_method_context_impl_gtk.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/x11_input_method_context_impl_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 #include <stddef.h>
@@ skipping 13 matching lines @@
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/views/linux_ui/linux_ui.h"
 
 namespace libgtkui {
 
 X11InputMethodContextImplGtk2::X11InputMethodContextImplGtk2(
     ui::LinuxInputMethodContextDelegate* delegate,
     bool is_simple)
     : delegate_(delegate),
-      gtk_context_(NULL),
-      gdk_last_set_client_window_(NULL) {
+      gtk_context_(nullptr),
+      gdk_last_set_client_window_(nullptr) {
   CHECK(delegate_);
 
   ResetXModifierKeycodesCache();
 
   gtk_context_ =
       is_simple ? gtk_im_context_simple_new() : gtk_im_multicontext_new();
 
   g_signal_connect(gtk_context_, "commit", G_CALLBACK(OnCommitThunk), this);
   g_signal_connect(gtk_context_, "preedit-changed",
                    G_CALLBACK(OnPreeditChangedThunk), this);
   g_signal_connect(gtk_context_, "preedit-end", G_CALLBACK(OnPreeditEndThunk),
                    this);
   g_signal_connect(gtk_context_, "preedit-start",
                    G_CALLBACK(OnPreeditStartThunk), this);
   // TODO(shuchen): Handle operations on surrounding text.
   // "delete-surrounding" and "retrieve-surrounding" signals should be
   // handled.
 }
 
 X11InputMethodContextImplGtk2::~X11InputMethodContextImplGtk2() {
   if (gtk_context_) {
     g_object_unref(gtk_context_);
-    gtk_context_ = NULL;
+    gtk_context_ = nullptr;
   }
 }
 
 // Overriden from ui::LinuxInputMethodContext
 
 bool X11InputMethodContextImplGtk2::DispatchKeyEvent(
     const ui::KeyEvent& key_event) {
   if (!key_event.HasNativeEvent() || !gtk_context_)
     return false;
 
@@ skipping 112 matching lines @@
   XKeyEvent& xkey = xkeyevent.xkey;
 
   // Get a GdkDisplay.
   GdkDisplay* display = gdk_x11_lookup_xdisplay(xkey.display);
   if (!display) {
     // Fall back to the default display.
     display = gdk_display_get_default();
   }
   if (!display) {
     LOG(ERROR) << "Cannot get a GdkDisplay for a key event.";
-    return NULL;
+    return nullptr;
   }
   // Get a keysym and group.
   KeySym keysym = NoSymbol;
   guint8 keyboard_group = 0;
-  XLookupString(&xkey, NULL, 0, &keysym, NULL);
+  XLookupString(&xkey, nullptr, 0, &keysym, nullptr);
   GdkKeymap* keymap = gdk_keymap_get_for_display(display);
-  GdkKeymapKey* keys = NULL;
-  guint* keyvals = NULL;
+  GdkKeymapKey* keys = nullptr;
+  guint* keyvals = nullptr;
   gint n_entries = 0;
   if (keymap && gdk_keymap_get_entries_for_keycode(keymap, xkey.keycode, &keys,
                                                    &keyvals, &n_entries)) {
     for (gint i = 0; i < n_entries; ++i) {
       if (keyvals[i] == keysym) {
         keyboard_group = keys[i].group;
         break;
       }
     }
   }
   g_free(keys);
-  keys = NULL;
+  keys = nullptr;
   g_free(keyvals);
-  keyvals = NULL;
+  keyvals = nullptr;
 // Get a GdkWindow.
 #if GTK_CHECK_VERSION(2, 24, 0)
   GdkWindow* window = gdk_x11_window_lookup_for_display(display, xkey.window);
 #else
   GdkWindow* window = gdk_window_lookup_for_display(display, xkey.window);
 #endif
   if (window)
     g_object_ref(window);
   else
 #if GTK_CHECK_VERSION(2, 24, 0)
     window = gdk_x11_window_foreign_new_for_display(display, xkey.window);
 #else
     window = gdk_window_foreign_new_for_display(display, xkey.window);
 #endif
   if (!window) {
     LOG(ERROR) << "Cannot get a GdkWindow for a key event.";
-    return NULL;
+    return nullptr;
   }
 
   // Create a GdkEvent.
   GdkEventType event_type =
       xkey.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
   GdkEvent* event = gdk_event_new(event_type);
   event->key.type = event_type;
   event->key.window = window;
   // GdkEventKey and XKeyEvent share the same definition for time and state.
   event->key.send_event = xkey.send_event;
   event->key.time = xkey.time;
   event->key.state = xkey.state;
   event->key.keyval = keysym;
   event->key.length = 0;
-  event->key.string = NULL;
+  event->key.string = nullptr;
   event->key.hardware_keycode = xkey.keycode;
   event->key.group = keyboard_group;
   event->key.is_modifier = IsKeycodeModifierKey(xkey.keycode);
 
   char keybits[32] = {0};
   XQueryKeymap(xkey.display, keybits);
   if (IsAnyOfKeycodesPressed(meta_keycodes_, keybits, sizeof keybits * 8))
     event->key.state |= GDK_META_MASK;
   if (IsAnyOfKeycodesPressed(super_keycodes_, keybits, sizeof keybits * 8))
     event->key.state |= GDK_SUPER_MASK;
@@ skipping 29 matching lines @@
   if (context != gtk_context_)
     return;
 
   delegate_->OnCommit(base::UTF8ToUTF16(text));
 }
 
 void X11InputMethodContextImplGtk2::OnPreeditChanged(GtkIMContext* context) {
   if (context != gtk_context_)
     return;
 
-  gchar* str = NULL;
-  PangoAttrList* attrs = NULL;
+  gchar* str = nullptr;
+  PangoAttrList* attrs = nullptr;
   gint cursor_pos = 0;
   gtk_im_context_get_preedit_string(context, &str, &attrs, &cursor_pos);
   ui::CompositionText composition_text;
   ui::ExtractCompositionTextFromGtkPreedit(str, attrs, cursor_pos,
                                            &composition_text);
   g_free(str);
   pango_attr_list_unref(attrs);
 
   delegate_->OnPreeditChanged(composition_text);
 }
 
 void X11InputMethodContextImplGtk2::OnPreeditEnd(GtkIMContext* context) {
   if (context != gtk_context_)
     return;
 
   delegate_->OnPreeditEnd();
 }
 
 void X11InputMethodContextImplGtk2::OnPreeditStart(GtkIMContext* context) {
   if (context != gtk_context_)
     return;
 
   delegate_->OnPreeditStart();
 }
 
 }  // namespace libgtkui