Move a bunch of random other files to src/ui/base...

chrome/browser/renderer_host/backing_store_x.cc

 // Copyright (c) 2010 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/renderer_host/backing_store_x.h"
 
 #include <cairo-xlib.h>
 #include <gtk/gtk.h>
 #include <stdlib.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
 #if defined(OS_OPENBSD) || defined(OS_FREEBSD)
 #include <sys/endian.h>
 #endif
 
 #include <algorithm>
 #include <utility>
 #include <limits>
 
 #include "app/surface/transport_dib.h"
-#include "app/x11_util.h"
-#include "app/x11_util_internal.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "gfx/rect.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/base/x/x11_util_internal.h"
 
 // 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:
@@ skipping 15 matching lines @@
   XShmDetach(display, shminfo);
   XDestroyImage(image);
   shmdt(shminfo->shmaddr);
 }
 
 BackingStoreX::BackingStoreX(RenderWidgetHost* widget,
                             const gfx::Size& size,
                             void* visual,
                             int depth)
     : BackingStore(widget, size),
-      display_(x11_util::GetXDisplay()),
-      shared_memory_support_(x11_util::QuerySharedMemorySupport(display_)),
-      use_render_(x11_util::QueryRenderSupport(display_)),
+      display_(ui::GetXDisplay()),
+      shared_memory_support_(ui::QuerySharedMemorySupport(display_)),
+      use_render_(ui::QueryRenderSupport(display_)),
       visual_(visual),
       visual_depth_(depth),
-      root_window_(x11_util::GetX11RootWindow()) {
+      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
 
   pixmap_ = XCreatePixmap(display_, root_window_,
                           size.width(), size.height(), depth);
 
   if (use_render_) {
     picture_ = XRenderCreatePicture(
         display_, pixmap_,
-        x11_util::GetRenderVisualFormat(display_,
-                                        static_cast<Visual*>(visual)),
-                                        0, NULL);
+        ui::GetRenderVisualFormat(display_,
+                                  static_cast<Visual*>(visual)),
+                                  0, NULL);
     pixmap_bpp_ = 0;
   } else {
     picture_ = 0;
-    pixmap_bpp_ = x11_util::BitsPerPixelForPixmapDepth(display_, depth);
+    pixmap_bpp_ = ui::BitsPerPixelForPixmapDepth(display_, depth);
   }
 
   pixmap_gc_ = XCreateGC(display_, pixmap_, 0, NULL);
 }
 
 BackingStoreX::BackingStoreX(RenderWidgetHost* widget, const gfx::Size& size)
     : BackingStore(widget, size),
       display_(NULL),
-      shared_memory_support_(x11_util::SHARED_MEMORY_NONE),
+      shared_memory_support_(ui::SHARED_MEMORY_NONE),
       use_render_(false),
       pixmap_bpp_(0),
       visual_(NULL),
       visual_depth_(-1),
       root_window_(0),
       pixmap_(0),
       picture_(0),
       pixmap_gc_(NULL) {
 }
 
@@ skipping 17 matching lines @@
 void BackingStoreX::PaintRectWithoutXrender(
     TransportDIB* bitmap,
     const gfx::Rect& bitmap_rect,
     const std::vector<gfx::Rect>& copy_rects) {
   const int width = bitmap_rect.width();
   const int height = bitmap_rect.height();
   Pixmap pixmap = XCreatePixmap(display_, root_window_, width, height,
                                 visual_depth_);
 
   // Draw ARGB transport DIB onto our pixmap.
-  x11_util::PutARGBImage(display_, visual_, visual_depth_, pixmap,
-                         pixmap_gc_, static_cast<uint8*>(bitmap->memory()),
-                         width, height);
+  ui::PutARGBImage(display_, visual_, visual_depth_, pixmap,
+                   pixmap_gc_, static_cast<uint8*>(bitmap->memory()),
+                   width, height);
 
   for (size_t i = 0; i < copy_rects.size(); i++) {
     const gfx::Rect& copy_rect = copy_rects[i];
     XCopyArea(display_,
               pixmap,                           // src
               pixmap_,                          // dest
               static_cast<GC>(pixmap_gc_),      // gc
               copy_rect.x() - bitmap_rect.x(),  // src_x
               copy_rect.y() - bitmap_rect.y(),  // src_y
               copy_rect.width(),                // width
@@ skipping 26 matching lines @@
   TransportDIB* dib = process->GetTransportDIB(bitmap);
   if (!dib)
     return;
 
   if (!use_render_)
     return PaintRectWithoutXrender(dib, bitmap_rect, copy_rects);
 
   Picture picture;
   Pixmap pixmap;
 
-  if (shared_memory_support_ == x11_util::SHARED_MEMORY_PIXMAP) {
+  if (shared_memory_support_ == ui::SHARED_MEMORY_PIXMAP) {
     XShmSegmentInfo shminfo = {0};
     shminfo.shmseg = dib->MapToX(display_);
 
     // The NULL in the following is the |data| pointer: this is an artifact of
     // Xlib trying to be helpful, rather than just exposing the X protocol. It
     // assumes that we have the shared memory segment mapped into our memory,
     // which we don't, and it's trying to calculate an offset by taking the
     // difference between the |data| pointer and the address of the mapping in
     // |shminfo|. Since both are NULL, the offset will be calculated to be 0,
     // which is correct for us.
     pixmap = XShmCreatePixmap(display_, root_window_, NULL, &shminfo,
                               width, height, 32);
   } else {
     // We don't have shared memory pixmaps.  Fall back to creating a pixmap
     // ourselves and putting an image on it.
     pixmap = XCreatePixmap(display_, root_window_, width, height, 32);
     GC gc = XCreateGC(display_, pixmap, 0, NULL);
 
-    if (shared_memory_support_ == x11_util::SHARED_MEMORY_PUTIMAGE) {
+    if (shared_memory_support_ == ui::SHARED_MEMORY_PUTIMAGE) {
       const XID shmseg = dib->MapToX(display_);
 
       XShmSegmentInfo shminfo;
       memset(&shminfo, 0, sizeof(shminfo));
       shminfo.shmseg = shmseg;
       shminfo.shmaddr = static_cast<char*>(dib->memory());
 
       XImage* image = XShmCreateImage(display_, static_cast<Visual*>(visual_),
                                       32, ZPixmap,
                                       shminfo.shmaddr, &shminfo,
@@ skipping 45 matching lines @@
       image.blue_mask = 0xff0000;
       image.data = static_cast<char*>(dib->memory());
 
       XPutImage(display_, pixmap, gc, &image,
                 0, 0 /* source x, y */, 0, 0 /* dest x, y */,
                 width, height);
     }
     XFreeGC(display_, gc);
   }
 
-  picture = x11_util::CreatePictureFromSkiaPixmap(display_, pixmap);
+  picture = ui::CreatePictureFromSkiaPixmap(display_, pixmap);
 
   for (size_t i = 0; i < copy_rects.size(); i++) {
     const gfx::Rect& copy_rect = copy_rects[i];
     XRenderComposite(display_,
                      PictOpSrc,                        // op
                      picture,                          // src
                      0,                                // mask
                      picture_,                         // dest
                      copy_rect.x() - bitmap_rect.x(),  // src_x
                      copy_rect.y() - bitmap_rect.y(),  // src_y
                      0,                                // mask_x
                      0,                                // mask_y
                      copy_rect.x(),                    // dest_x
                      copy_rect.y(),                    // dest_y
                      copy_rect.width(),                // width
                      copy_rect.height());              // height
   }
 
   // In the case of shared memory, we wait for the composite to complete so that
   // we are sure that the X server has finished reading from the shared memory
   // segment.
-  if (shared_memory_support_ != x11_util::SHARED_MEMORY_NONE)
+  if (shared_memory_support_ != ui::SHARED_MEMORY_NONE)
     XSync(display_, False);
 
   XRenderFreePicture(display_, picture);
   XFreePixmap(display_, pixmap);
 }
 
 bool BackingStoreX::CopyFromBackingStore(const gfx::Rect& rect,
                                          skia::PlatformCanvas* output) {
   base::TimeTicks begin_time = base::TimeTicks::Now();
 
   if (visual_depth_ < 24) {
     // CopyFromBackingStore() copies pixels out of the XImage
     // in a way that assumes that each component (red, green,
     // blue) is a byte.  This doesn't work on visuals which
     // encode a pixel color with less than a byte per color.
     return false;
   }
 
   const int width = std::min(size().width(), rect.width());
   const int height = std::min(size().height(), rect.height());
 
   XImage* image;
   XShmSegmentInfo shminfo;  // Used only when shared memory is enabled.
-  if (shared_memory_support_ != x11_util::SHARED_MEMORY_NONE) {
+  if (shared_memory_support_ != ui::SHARED_MEMORY_NONE) {
     // Use shared memory for faster copies when it's available.
     Visual* visual = static_cast<Visual*>(visual_);
     memset(&shminfo, 0, sizeof(shminfo));
     image = XShmCreateImage(display_, visual, 32,
                             ZPixmap, NULL, &shminfo, width, height);
     if (!image) {
       return false;
     }
     // Create the shared memory segment for the image and map it.
     if (image->bytes_per_line == 0 || image->height == 0 ||
@@ skipping 28 matching lines @@
     image = XGetImage(display_, pixmap_,
                       rect.x(), rect.y(), width, height,
                       AllPlanes, ZPixmap);
   }
 
   // TODO(jhawkins): Need to convert the image data if the image bits per pixel
   // is not 32.
   // Note that this also initializes the output bitmap as opaque.
   if (!output->initialize(width, height, true) ||
       image->bits_per_pixel != 32) {
-    if (shared_memory_support_ != x11_util::SHARED_MEMORY_NONE)
+    if (shared_memory_support_ != ui::SHARED_MEMORY_NONE)
       DestroySharedImage(display_, image, &shminfo);
     else
       XDestroyImage(image);
     return false;
   }
 
   // The X image might have a different row stride, so iterate through
   // it and copy each row out, only up to the pixels we're actually
   // using.  This code assumes a visual mode where a pixel is
   // represented using a 32-bit unsigned int, with a byte per component.
   SkBitmap bitmap = output->getTopPlatformDevice().accessBitmap(true);
   for (int y = 0; y < height; y++) {
     const uint32* src_row = reinterpret_cast<uint32*>(
         &image->data[image->bytes_per_line * y]);
     uint32* dest_row = bitmap.getAddr32(0, y);
     for (int x = 0; x < width; ++x, ++dest_row) {
       // Force alpha to be 0xff, because otherwise it causes rendering problems.
       *dest_row = src_row[x] | 0xff000000;
     }
   }
 
-  if (shared_memory_support_ != x11_util::SHARED_MEMORY_NONE)
+  if (shared_memory_support_ != ui::SHARED_MEMORY_NONE)
     DestroySharedImage(display_, image, &shminfo);
   else
     XDestroyImage(image);
 
   HISTOGRAM_TIMES("BackingStore.RetrievalFromX",
                   base::TimeTicks::Now() - begin_time);
   return true;
 }
 
 void BackingStoreX::ScrollBackingStore(int dx, int dy,
@@ skipping 68 matching lines @@
   cairo_set_source(cr, pattern);
   cairo_pattern_destroy(pattern);
 
   cairo_identity_matrix(cr);
 
   cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height());
   cairo_fill(cr);
   cairo_destroy(cr);
 }
 #endif