wm: Update a lot of code to use structs from geometry.h.

x11/real_x_connection.cc

 // Copyright (c) 2010 The Chromium OS 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 "window_manager/x11/real_x_connection.h"
 
 extern "C" {
 #include <xcb/composite.h>
 #include <xcb/damage.h>
 #include <xcb/randr.h>
@@ skipping 687 matching lines @@
   int count = 0, ordering = 0;
   XRectangle* rects =
       XShapeGetRectangles(display_, xid, ShapeBounding, &count, &ordering);
   if (int error = UntrapErrors()) {
     LOG(WARNING) << "Got X error while getting bounding rectangles for "
                  << XidStr(xid) << ": " << GetErrorText(error);
     return false;
   }
   bytemap->Clear(0x0);
   for (int i = 0; i < count; ++i) {
-    const XRectangle& rect = rects[i];
-    bytemap->SetRectangle(rect.x, rect.y, rect.width, rect.height, 0xff);
+    const XRectangle& xrect = rects[i];
+    const Rect rect(xrect.x, xrect.y, xrect.width, xrect.height);
+    bytemap->SetRectangle(rect, 0xff);
   }
   XFree(rects);
 
   // Note that xcb_shape_get_rectangles() appears to be broken up to and
   // including libxcb 1.4, the version in Ubuntu 9.10 (the rectangles that
   // it returns are full of garbage values), but works correctly in 1.5.
   // TODO: Switch to the XCB version of this code if/when we go to 1.5.
 #if 0
   xcb_shape_get_rectangles_cookie_t cookie =
       xcb_shape_get_rectangles(xcb_conn_, xid, XCB_SHAPE_SK_BOUNDING);
   xcb_generic_error_t* error = NULL;
   scoped_ptr_malloc<xcb_shape_get_rectangles_reply_t> reply(
       xcb_shape_get_rectangles_reply(xcb_conn_, cookie, &error));
   scoped_ptr_malloc<xcb_generic_error_t> scoped_error(error);
   if (error || !reply.get()) {
     LOG(WARNING) << "Got X error while getting bounding region for "
                  << XidStr(xid);
     return false;
   }
 
   bytemap->Clear(0x0);
   xcb_rectangle_t* rectangles =
       xcb_shape_get_rectangles_rectangles(reply.get());
   int num_rectangles = xcb_shape_get_rectangles_rectangles_length(reply.get());
   for (int i = 0; i < num_rectangles; ++i) {
-    const xcb_rectangle_t& rect = rectangles[i];
-    bytemap->SetRectangle(rect.x, rect.y, rect.width, rect.height, 0xff);
+    const xcb_rectangle_t& xrect = rectangles[i];
+    const Rect rect(xrect.x, xrect.y, xrect.width, xrect.height);
+    bytemap->SetRectangle(rect, 0xff);
   }
 #endif
 
   return true;
 }
 
 bool RealXConnection::SetWindowBoundingRegionToRect(XWindow xid,
                                                     const Rect& region) {
   xcb_rectangle_t rect;
   rect.x = region.x;
@@ skipping 328 matching lines @@
                   << " drawable=" << XidStr(drawable)
                   << " drawable_depth=" << drawable_depth
                   << " image_depth=" << image->bits_per_pixel
                   << " lsb_first=" << (image->byte_order == LSBFirst);
     XDestroyImage(image);
     return false;
   }
 
   const size_t data_size = image->bytes_per_line * image->height;
   const int format_bpp = GetBitsPerPixelInImageFormat(*format_out);
-  const size_t expected_size = bounds.width * bounds.height * format_bpp / 8;
+  const size_t expected_size = bounds.size().area() * format_bpp / 8;
   if (data_size != expected_size) {
     DLOG(WARNING) << "Expected " << expected_size << " bytes in image from "
                   << XidStr(drawable) << " (" << bounds.size() << " at "
                   << format_bpp << " bpp) " << " but got " << data_size;
     XDestroyImage(image);
     return false;
   }
 
   data_out->reset(reinterpret_cast<uint8_t*>(image->data));
   image->data = NULL;  // Take ownership so Xlib doesn't free it.
@@ skipping 264 matching lines @@
       display_,
       depth == 24 ? PictStandardRGB24 : PictStandardARGB32);
   pa.repeat = True;
   XPicture r = XRenderCreatePicture(display_, drawable, format, CPRepeat, &pa);
   return r;
 }
 
 XPixmap RealXConnection::CreatePixmapFromContainer(
     const ImageContainer& container) {
   Size size = container.size();
-  int data_size = size.width * size.height * 4;
+  int data_size = size.area() * 4;
 
   // XDestroyImage will free() this.
   char* pixmap_data = static_cast<char*>(malloc(data_size));
 
   // Premultiply the RGB channels.
   memcpy(pixmap_data, container.data(), data_size);
-  for (int i = 0; i < size.width * size.height; i++) {
+  for (int i = 0; i < size.area(); i++) {
      pixmap_data[i*4+0] = pixmap_data[i*4+0] * pixmap_data[i*4+3] / 255;
      pixmap_data[i*4+1] = pixmap_data[i*4+1] * pixmap_data[i*4+3] / 255;
      pixmap_data[i*4+2] = pixmap_data[i*4+2] * pixmap_data[i*4+3] / 255;
   }
 
   XPixmap pixmap = XCreatePixmap(display_, root_, size.width, size.height, 32);
 
   XImage* image = XCreateImage(
       display_,
       DefaultVisual(display_, DefaultScreen(display_)),
@@ skipping 256 matching lines @@
   string message;
   StringAppendV(&message, format, ap);
   va_end(ap);
 
   LOG(WARNING) << "Got XCB error while " << message << ": "
                << GetErrorText(error->error_code);
   return false;
 }
 
 }  // namespace window_manager