Delete the GTK+ port of Chrome.

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 43 matching lines @@
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #endif
 
 #if defined(USE_AURA)
 #include <X11/Xcursor/Xcursor.h>
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/skia_util.h"
 #endif
 
-#if defined(TOOLKIT_GTK)
-#include <gdk/gdk.h>
-#include <gtk/gtk.h>
-#include "ui/gfx/gdk_compat.h"
-#include "ui/gfx/gtk_compat.h"
-#endif
-
 namespace ui {
 
 namespace {
 
 // Used to cache the XRenderPictFormat for a visual/display pair.
 struct CachedPictFormat {
   bool equals(XDisplay* display, Visual* visual) const {
     return display == this->display && visual == this->visual;
   }
 
@@ skipping 442 matching lines @@
 }
 
 XID GetX11RootWindow() {
   return DefaultRootWindow(gfx::GetXDisplay());
 }
 
 bool GetCurrentDesktop(int* desktop) {
   return GetIntProperty(GetX11RootWindow(), "_NET_CURRENT_DESKTOP", desktop);
 }
 
-#if defined(TOOLKIT_GTK)
-XID GetX11WindowFromGtkWidget(GtkWidget* widget) {
-  return GDK_WINDOW_XID(gtk_widget_get_window(widget));
-}
-
-XID GetX11WindowFromGdkWindow(GdkWindow* window) {
-  return GDK_WINDOW_XID(window);
-}
-
-GtkWindow* GetGtkWindowFromX11Window(XID xid) {
-  GdkWindow* gdk_window =
-      gdk_x11_window_lookup_for_display(gdk_display_get_default(), xid);
-  if (!gdk_window)
-    return NULL;
-  GtkWindow* gtk_window = NULL;
-  gdk_window_get_user_data(gdk_window,
-                           reinterpret_cast<gpointer*>(&gtk_window));
-  if (!gtk_window)
-    return NULL;
-  return gtk_window;
-}
-
-void* GetVisualFromGtkWidget(GtkWidget* widget) {
-  return GDK_VISUAL_XVISUAL(gtk_widget_get_visual(widget));
-}
-#endif  // defined(TOOLKIT_GTK)
-
 void SetHideTitlebarWhenMaximizedProperty(XID window,
                                           HideTitlebarWhenMaximized property) {
   // XChangeProperty() expects "hide" to be long.
   unsigned long hide = property;
   XChangeProperty(gfx::GetXDisplay(),
       window,
       GetAtom("_GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"),
       XA_CARDINAL,
       32,  // size in bits
       PropModeReplace,
@@ skipping 396 matching lines @@
                   property,
                   type,
                   8,
                   PropModeReplace,
                   reinterpret_cast<const unsigned char*>(value.c_str()),
                   value.size());
   return !err_tracker.FoundNewError();
 }
 
 Atom GetAtom(const char* name) {
-#if defined(TOOLKIT_GTK)
-  return gdk_x11_get_xatom_by_name_for_display(
-      gdk_display_get_default(), name);
-#else
   // TODO(derat): Cache atoms to avoid round-trips to the server.
   return XInternAtom(gfx::GetXDisplay(), name, false);
-#endif
 }
 
 void SetWindowClassHint(XDisplay* display,
                         XID window,
                         const std::string& res_name,
                         const std::string& res_class) {
   XClassHint class_hints;
   // const_cast is safe because XSetClassHint does not modify the strings.
   // Just to be safe, the res_name and res_class parameters are local copies,
   // not const references.
@@ skipping 394 matching lines @@
         return std::find(atom_properties.begin(), atom_properties.end(), atom)
             != atom_properties.end();
       }
     }
   }
 
   gfx::Rect window_rect;
   if (!ui::GetWindowRect(window, &window_rect))
     return false;
 
-#if defined(TOOLKIT_GTK)
-  // As the last resort, check if the window size is as large as the main
-  // screen.
-  GdkRectangle monitor_rect;
-  gdk_screen_get_monitor_geometry(gdk_screen_get_default(), 0, &monitor_rect);
-
-  return monitor_rect.x == window_rect.x() &&
-         monitor_rect.y == window_rect.y() &&
-         monitor_rect.width == window_rect.width() &&
-         monitor_rect.height == window_rect.height();
-#else
   // We can't use gfx::Screen here because we don't have an aura::Window. So
   // instead just look at the size of the default display.
   //
   // TODO(erg): Actually doing this correctly would require pulling out xrandr,
   // which we don't even do in the desktop screen yet.
   ::XDisplay* display = gfx::GetXDisplay();
   ::Screen* screen = DefaultScreenOfDisplay(display);
   int width = WidthOfScreen(screen);
   int height = HeightOfScreen(screen);
   return window_rect.size() == gfx::Size(width, height);
-#endif
 }
 
 const unsigned char* XRefcountedMemory::front() const {
   return x11_data_;
 }
 
 size_t XRefcountedMemory::size() const {
   return length_;
 }
 
@@ skipping 159 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui