Move XID, XDisplay, GetXDisplay and a few other types to ui/gfx/x/x11_types.h

content/browser/renderer_host/backing_store_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 "content/browser/renderer_host/backing_store_gtk.h"
 
 #include <cairo-xlib.h>
 #include <gtk/gtk.h>
 #include <stdlib.h>
 #include <sys/ipc.h>
@@ skipping 11 matching lines @@
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/gtk/gtk_signal.h"
-#include "ui/base/x/x11_util.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/x/x11_types.h"
 #include "ui/surface/transport_dib.h"
 
 namespace content {
 namespace {
 
 // Assume that somewhere along the line, someone will do width * height * 4
 // with signed numbers. If the maximum value is 2**31, then 2**31 / 4 =
 // 2**29 and floor(sqrt(2**29)) = 23170.
 
 // Max height and width for layers
 static const int kMaxVideoLayerSize = 23170;
 
 
 // X Backing Stores:
 //
 // Unlike Windows, where the backing store is kept in heap memory, we keep our
 // backing store in the X server, as a pixmap. Thus expose events just require
 // instructing the X server to copy from the backing store to the window.
 //
 // The backing store is in the same format as the visual which our main window
 // is using. Bitmaps from the renderer are uploaded to the X server, either via
 // shared memory or over the wire, and XRENDER is used to convert them to the
 // correct format for the backing store.
 
 // Destroys the image and the associated shared memory structures. This is a
 // helper function for code using shared memory.
-void DestroySharedImage(Display* display,
+void DestroySharedImage(XDisplay* display,
                         XImage* image,
                         XShmSegmentInfo* shminfo) {
   XShmDetach(display, shminfo);
   XDestroyImage(image);
   shmdt(shminfo->shmaddr);
 }
 
 // So we don't don't want to call XSync(), which can block the UI loop for
 // ~100ms on first paint and is generally slow. We optionally use the
 // XSyncExtension to push a callback into the X11 event queue and get a
 // callback instead of blocking until the event queue is cleared.
 //
-// TODO(erg): If ui::GetXDisplay() ever gets fixed to handle multiple Displays,
+// TODO(erg): If gfx::GetXDisplay() ever gets fixed to handle multiple Displays,
 // this must be modified to be per Display instead of a Singleton.
 class XSyncHandler {
  public:
   static XSyncHandler* GetInstance() {
     return Singleton<XSyncHandler>::get();
   }
 
   bool Enabled() {
     return loaded_extension_;
   }
 
   void PushPaintCounter(TransportDIB* dib,
-                        Display* display,
+                        XDisplay* display,
                         Picture picture,
                         Pixmap pixmap,
                         const base::Closure& completion_callback);
 
  private:
   friend struct DefaultSingletonTraits<XSyncHandler>;
 
   // A struct that has cleanup and callback tasks that were queued into the
   // future and are run on |g_backing_store_sync_alarm| firing.
   struct BackingStoreEvents {
-    BackingStoreEvents(TransportDIB* dib, Display* d, Picture pic, Pixmap pix,
+    BackingStoreEvents(TransportDIB* dib, XDisplay* d, Picture pic, Pixmap pix,
                        const base::Closure& c)
         : dib(dib),
           display(d),
           picture(pic),
           pixmap(pix),
           closure(c) {
       dib->IncreaseInFlightCounter();
     }
 
     TransportDIB* dib;
 
     // The display we're running on.
-    Display* display;
+    XDisplay* display;
 
     // Data to delete.
     Picture picture;
     Pixmap pixmap;
 
     // Callback once everything else is done.
     base::Closure closure;
   };
 
   XSyncHandler();
@@ skipping 12 matching lines @@
   int xsync_error_base_;
 
   XSyncCounter backing_store_sync_counter_;
   XSyncAlarm backing_store_sync_alarm_;
 
   // A queue of pending paints that we clean up after as alarms fire.
   std::queue<BackingStoreEvents*> backing_store_events_;
 };
 
 void XSyncHandler::PushPaintCounter(TransportDIB* dib,
-                                    Display* display,
+                                    XDisplay* display,
                                     Picture picture,
                                     Pixmap pixmap,
                                     const base::Closure& completion_callback) {
   backing_store_events_.push(new BackingStoreEvents(
         dib, display, picture, pixmap, completion_callback));
 
   // Push a change counter event into the X11 event queue that will trigger our
   // alarm when it is processed.
   XSyncValue value;
   XSyncIntToValue(&value, 1);
-  XSyncChangeCounter(ui::GetXDisplay(),
+  XSyncChangeCounter(gfx::GetXDisplay(),
                      backing_store_sync_counter_,
                      value);
 }
 
 XSyncHandler::XSyncHandler()
     : loaded_extension_(false),
       xsync_event_base_(0),
       xsync_error_base_(0),
       backing_store_sync_counter_(0),
       backing_store_sync_alarm_(0) {
-  Display* display = ui::GetXDisplay();
+  XDisplay* display = gfx::GetXDisplay();
   if (XSyncQueryExtension(display,
                           &xsync_event_base_,
                           &xsync_error_base_)) {
     // Create our monotonically increasing counter.
     XSyncValue value;
     XSyncIntToValue(&value, 0);
     backing_store_sync_counter_ = XSyncCreateCounter(display, value);
 
     // Cerate our alarm that watches for changes to our counter.
     XSyncAlarmAttributes attributes;
     attributes.trigger.counter = backing_store_sync_counter_;
     backing_store_sync_alarm_ = XSyncCreateAlarm(display,
                                                  XSyncCACounter,
                                                  &attributes);
 
     // Add our filter to the message loop to handle alarm triggers.
     gdk_window_add_filter(NULL, &OnEventThunk, this);
 
     loaded_extension_ = true;
   }
 }
 
 XSyncHandler::~XSyncHandler() {
   if (loaded_extension_)
     gdk_window_remove_filter(NULL, &OnEventThunk, this);
 
-  XSync(ui::GetXDisplay(), False);
+  XSync(gfx::GetXDisplay(), False);
   while (!backing_store_events_.empty()) {
     // We delete the X11 resources we're holding onto. We don't run the
     // callbacks because we are shutting down.
     BackingStoreEvents* data = backing_store_events_.front();
     backing_store_events_.pop();
     XRenderFreePicture(data->display, data->picture);
     XFreePixmap(data->display, data->pixmap);
     data->dib->DecreaseInFlightCounter();
     delete data;
   }
@@ skipping 36 matching lines @@
   return GDK_FILTER_CONTINUE;
 }
 
 }  // namespace
 
 BackingStoreGtk::BackingStoreGtk(RenderWidgetHost* widget,
                                  const gfx::Size& size,
                                  void* visual,
                                  int depth)
     : BackingStore(widget, size),
-      display_(ui::GetXDisplay()),
+      display_(gfx::GetXDisplay()),
       shared_memory_support_(ui::QuerySharedMemorySupport(display_)),
       use_render_(ui::QueryRenderSupport(display_)),
       visual_(visual),
       visual_depth_(depth),
       root_window_(ui::GetX11RootWindow()) {
 #if defined(OS_OPENBSD) || defined(OS_FREEBSD)
   COMPILE_ASSERT(_BYTE_ORDER == _LITTLE_ENDIAN, assumes_little_endian);
 #else
   COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN, assumes_little_endian);
 #endif
@@ skipping 421 matching lines @@
 
   cairo_identity_matrix(cr);
 
   cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height());
   cairo_fill(cr);
   cairo_destroy(cr);
 }
 #endif
 
 }  // namespace content